Hacer que el proyecto sea compatible con la CLI para desarrolladores de Azure

Artículo
11/16/2023

La CLI para desarrolladores de Azure (azd) permite a los desarrolladores aplicar scaffolding a sus aplicaciones para la nube mediante plantillas hospedadas en GitHub. Microsoft proporciona varias plantillas para empezar. En este artículo, aprenderá a hacer que su propia aplicación azd sea compatible.

Descripción de la arquitectura de plantilla

En el diagrama siguiente se proporciona información general rápida sobre el proceso para crear una azd plantilla:

Diagram of Azure Developer CLI template workflow.

Todas las azd plantillas tienen la misma estructura de archivos, en función de azd las convenciones. En la jerarquía siguiente se muestra la estructura de directorios que creará en este tutorial.

├── .azdo                                        [ Configures an Azure Pipeline ]
├── .devcontainer                                [ For DevContainer ]
├── .github                                      [ Configures a GitHub workflow ]
├── .vscode                                      [ VS Code workspace configurations ]
├── .azure                                       [ Stores Azure configurations and environment variables ]
├── infra                                        [ Contains infrastructure as code files ]
│   ├── main.bicep/main.tf                       [ Main infrastructure file ]
│   ├── main.parameters.json/main.tfvars.json    [ Parameters file ]
│   └── core/modules                             [ Contains reusable Bicep/Terraform modules ]
└── azure.yaml                                   [ Describes the app and type of Azure resources]

Inicialización de la plantilla

El azd init comando se usa para inicializar la aplicación para aprovisionar e implementar los recursos de la aplicación en Azure. Este comando le pide que elija entre dos flujos de trabajo diferentes para inicializar una plantilla que se describe en las secciones siguientes.

Usar código en el directorio actual: seleccione esta opción para indicar azd a analizar el código del directorio para identificar qué tecnologías usa, como el lenguaje de programación, el marco de trabajo y el sistema de base de datos. azd Después, generará automáticamente recursos de plantilla, como el azure.yaml archivo de definición de servicio y la infra carpeta con archivos de infraestructura como código.
Seleccione una plantilla: seleccione esta opción para usar una plantilla existente como punto de partida. De forma predeterminada, azd le permite examinar plantillas desde la galería de Awesome AZD , pero también puede configurar sus propias galerías de plantillas. Al seleccionar una plantilla, los recursos de esa plantilla se agregarán al directorio del proyecto existente.

Los detalles de cada uno de estos flujos de trabajo se describen en las secciones siguientes.

Uso de código en el directorio
Uso de una plantilla

Puede seguir los pasos que se indican a continuación mediante su propio proyecto. Sin embargo, si prefiere seguir con una aplicación de ejemplo, clone el siguiente repositorio de inicio en un directorio vacío en el equipo:
```
git clone https://github.com/Azure-Samples/msdocs-python-flask-webapp-quickstart
```
Abra la herramienta de línea de comandos que prefiera en el directorio raíz del proyecto.
Ejecute el azd init comando para inicializar la plantilla.
```
azd init
```
Cuando se le solicite, seleccione la opción Usar código en el directorio actual. azd analiza el proyecto y proporciona un resumen de los servicios detectados y los recursos de hospedaje de Azure recomendados.
Seleccione Confirmar y continuar inicializando mi aplicación. azd genera los siguientes recursos en el directorio raíz del proyecto:
- Un azure.yaml archivo con las definiciones de servicio adecuadas.
- Carpeta infra con archivos de infraestructura como código para aprovisionar e implementar el proyecto en Azure.
- Una .azure carpeta con variables de entorno establecidas en un .env archivo.
Más adelante en el artículo se proporcionan más detalles sobre este proceso de detección y generación.
Los archivos generados funcionan tal cual para la aplicación de ejemplo proporcionada y también para sus propias aplicaciones. Si es necesario, los archivos generados se pueden modificar para adaptarlos a sus necesidades. Por ejemplo, puede que tenga que modificar aún más los archivos de infraestructura como código en la carpeta si la infra aplicación se basa en recursos de Azure más allá de los identificados por azd.
Ejecute el azd up comando para aprovisionar e implementar la aplicación en Azure.
```
azd up
```
Cuando se le solicite, seleccione la suscripción y la ubicación deseadas para comenzar el proceso de aprovisionamiento e implementación.
Cuando se complete el proceso, haga clic en el vínculo de la azd salida para abrir la aplicación en el explorador.

Explorar los pasos de inicialización

Al seleccionar el código Usar en el flujo de trabajo del directorio actual, el comando analiza el azd init proyecto y genera automáticamente el código en función de lo que detecta. En las secciones siguientes se explican los detalles de cómo funciona este proceso y qué tecnologías se admiten actualmente.

Detección

El azd init comando detecta los archivos de proyecto para los idiomas admitidos ubicados en el directorio y subdirectorios del proyecto. azd también examinará las dependencias del paquete para recopilar información sobre los marcos web o las bases de datos que usa la aplicación. Si es necesario, puede agregar o editar manualmente los componentes detectados como se muestra en el mensaje de resumen de confirmación.

La lógica de detección actual es la siguiente:

Idiomas admitidos:
- Python
- JavaScript/TypeScript
- .NET
- Java
Bases de datos admitidas:
- MongoDB
- PostgreSQL
Para Python y JavaScript/TypeScript, se detectan automáticamente marcos web y bases de datos.
Cuando un proyecto de JavaScript/TypeScript usa un marco web front-end (o del lado cliente), se clasifica como un servicio front-end. Si el servicio usa un marco web front-end que no se detecta actualmente, puede seleccionar JQuery para proporcionar un comportamiento y clasificación de servicios front-end equivalentes.

Generación

Después de confirmar los componentes detectados, azd init genera los archivos de infraestructura como código necesarios para implementar la aplicación en Azure.

La lógica de generación es la siguiente:

Hosts admitidos:
- Azure Container Apps.
En el caso de las bases de datos, la asignación admitida entre la tecnología de base de datos y el servicio usados:
- MongoDB: API de Azure CosmosDB para MongoDB
- PostgreSQL: servidor flexible de Azure Database for PostgreSQL
- Redis: complemento redis de Azure Container Apps
Los servicios que usan bases de datos tendrán variables de entorno que proporcionan conexión a la base de datos preconfigurada de forma predeterminada.
Cuando se detectan servicios front-end y back-end, se actualizará la configuración de CORS en el host de Azure para los servicios back-end para permitir el dominio de hospedaje predeterminado de los servicios front-end. Esto se puede modificar o quitar según sea necesario en la infraestructura como archivos de configuración de código.

Adición de compatibilidad con contenedores de desarrollo

También puede hacer que la plantilla sea compatible con contenedores de desarrollo y Codespaces. Un contenedor de desarrollo permite usar un contenedor como entorno de desarrollo completo. Se puede usar para ejecutar una aplicación, para separar herramientas, bibliotecas o entornos de ejecución necesarios para trabajar con un código base y para ayudar en la integración y las pruebas continuas. Los contenedores de desarrollo se pueden ejecutar local o remotamente, en una nube privada o pública. (Origen: https://containers.dev/)

Para agregar compatibilidad con contenedores de desarrollo:

Cree una carpeta .devcontainer en la raíz del proyecto.
Cree un devcontainer.json archivo dentro de la .devcontainer carpeta con las configuraciones deseadas. La azd plantilla de inicio proporciona un archivo de ejemplo devcontainer.json que puede copiar en el proyecto y modificar según sea necesario.

Obtenga más información sobre cómo trabajar con contenedores de desarrollo en la documentación de Visual Studio Code.

Adición de compatibilidad con una canalización de CI/CD

También puede agregar compatibilidad con CI/CD en la plantilla mediante acciones de GitHub o Azure DevOps mediante los pasos siguientes:

Agregue una .github carpeta para acciones de GitHub o una .ado carpeta para Azure DevOps a la raíz del proyecto.
Agregue un archivo de flujo de trabajo a la nueva carpeta. La azd plantilla de inicio proporciona un archivo de flujo de trabajo de Acciones de GitHub de ejemplo y archivos de canalizaciones de Azure DevOps de ejemplo para cada plataforma que puede copiar en el proyecto y modificar según sea necesario.
Es posible que también tenga que actualizar el archivo de la main.parameters.jsoninfra carpeta con las variables de entorno necesarias para que se ejecute el flujo de trabajo.

El flujo de trabajo Seleccionar una plantilla le permite elegir una plantilla existente azd que se usará como punto de partida. El contenido de la plantilla seleccionada se agrega al directorio raíz del proyecto. La mayoría de las plantillas proporcionan el conjunto necesario de azd archivos y carpetas, y algunas plantillas incluyen archivos de infraestructura como código completos para aprovisionar recursos de Azure para una pila de aplicaciones elegida.

En este ejemplo, usará la plantilla Starter - Bicep , que incluye la estructura esencial de una azd plantilla y algún código reutilizable útil para empezar.

Para seguir los pasos que se indican a continuación mediante una aplicación de ejemplo existente, clone el siguiente proyecto de inicio en un directorio vacío en el equipo:
```
git clone https://github.com/Azure-Samples/msdocs-python-flask-webapp-quickstart
```
En la herramienta de línea de comandos que prefiera, vaya al directorio raíz del proyecto clonado.
Ejecute el azd init comando para inicializar una azd plantilla.
```
azd init
```
Cuando se le solicite, elija la opción Seleccionar una plantilla.
En la lista de plantillas, seleccione Starter - Bicep. Es posible que tenga que desplazarse por la lista mediante las teclas de dirección del teclado para buscar la plantilla.
Cuando se le solicite, escriba un nombre de entorno corto, como testenv.

Después de ejecutar azd init, se agregan los siguientes recursos al proyecto:

├── .azdo                                        [ Configures an Azure Pipeline ]
├── .devcontainer                                [ For DevContainer ]
├── .github                                      [ Configures a GitHub workflow ]
├── .vscode                                      [ VS Code workspace configurations ]
├── .azure                                       [ Stores Azure configurations and environment variables ]
├── infra                                        [ Contains infrastructure as code files ]
│   ├── main.bicep/main.tf                       [ Main infrastructure file ]
│   ├── main.parameters.json/main.tfvars.json    [ Parameters file ]
│   └── core/modules                             [ Contains reusable Bicep/Terraform modules ]
└── azure.yaml                                   [ Describes the app and type of Azure resources]

Actualización de los archivos de Bicep

El proyecto ahora contiene la estructura principal y los recursos de una azd plantilla. Sin embargo, para aprovisionar los recursos de Azure para su proyecto específico, es necesario actualizar los archivos de Bicep de la infra carpeta. Para hospedar la aplicación de ejemplo, necesitará los siguientes recursos:

Un plan de servicio de App de Azure
Un servicio App de Azure que se ejecuta en Linux

Abra el directorio del proyecto de nivel superior en el editor que prefiera, como Visual Studio Code.
Abra el archivo en el main.bicep editor. Este archivo contiene código reutilizable útil para configurar variables esenciales, parámetros y convenciones de nomenclatura. Debajo del bloque de comentarios alrededor de la línea 50 que lee Add resources to be provisioned below, agregue lo siguiente:
```
// Creates an app service instance to host the app
module web './core/host/appservice.bicep' = {
  name: 'web'
  scope: rg
  params: {
    name: '${abbrs.webSitesAppService}web-${resourceToken}'
    location: location
    tags: union(tags, { 'azd-service-name': 'web' })
    appServicePlanId: appServicePlan.outputs.id
    runtimeName: 'python'
    runtimeVersion: '3.8'
    scmDoBuildDuringDeployment: true
  }
}

// Create an App Service Plan to group applications under the same payment plan and SKU
module appServicePlan './core/host/appserviceplan.bicep' = {
  name: 'appserviceplan'
  scope: rg
  params: {
    name: '${abbrs.webServerFarms}${resourceToken}'
    location: location
    tags: tags
    sku: {
      name: 'B1'
    }
  }
}
```
Nota:
- Se genera una cadena única basada en el identificador de suscripción y se usa como variable ${resourceToken} . Este token se anexa al nombre de todos los recursos de Azure creados por azd. azd usa etiquetas para identificar recursos para que pueda modificar los nombres en función de la convención de nomenclatura de su organización.
- La 'azd-service-name': 'web' etiqueta del servicio de aplicaciones es el valor azd que usa para identificar el host de implementación. El valor debe ser el mismo que el definido para el servicio en el archivo azure.yaml .

Actualización del archivo azure.yaml

Para implementar la aplicación, azd debe saber más sobre la aplicación. El azure.yaml archivo se usa para definir la ubicación del código fuente, el idioma y el servicio de hospedaje de Azure para cada servicio de la aplicación. Para más información, consulte el esquema azure.yaml.

Abra en azure.yaml la raíz del proyecto.

Agregue las líneas siguientes a la parte inferior del archivo:

name: msdocs-python-flask-webapp-quickstart
services:
  web:
    project: .
    language: py
    host: appservice

Aprovisionamiento e implementación de la plantilla

Guarde todos los cambios y ejecute el siguiente comando para aprovisionar e implementar los recursos de la aplicación en Azure:
```
azd up
```
Cuando finalice el comando, haga clic en el vínculo de la salida del comando para ir al sitio implementado.

El proyecto ahora es compatible con la CLI para desarrolladores de Azure y se puede usar como plantilla.

Nota:

azd también admite el uso de Buildpack para incluir en contenedores las aplicaciones de forma predeterminada. Si la azd plantilla tiene como destino Azure Container Apps o Azure Kubernetes Service, pero no incluye un archivo de Docker, azd genera automáticamente una imagen mediante Buildpack.

Configuración de la canalización de CI/CD

Si la plantilla incluye compatibilidad con Acciones de GitHub o Azure Pipelines, puede configurar una canalización de CI/CD mediante los pasos siguientes:

Ejecute el siguiente comando para insertar actualizaciones en el repositorio. El flujo de trabajo acciones de GitHub se desencadena debido a la actualización.
```
azd pipeline config    
```
Con el explorador, vaya al repositorio de GitHub del proyecto.
Seleccione Acciones para ver el flujo de trabajo en ejecución.

Limpieza de recursos

Cuando ya no necesite los recursos creados en este artículo, ejecute el siguiente comando:

azd down

Consulte también

Cree archivos de Bicep con Visual Studio Code para obtener una introducción a trabajar con archivos de Bicep.
Ejemplos de Bicep
Cómo descompilar plantillas de Azure Resource Manager (plantillas de ARM) en Bicep
Esquema azure.yaml de la CLI para desarrolladores de Azure

Solicitar ayuda

Para obtener información sobre cómo archivar un error, solicitar ayuda o proponer una nueva característica para la CLI para desarrolladores de Azure, visite la página de solución de problemas y soporte técnico .

Pasos siguientes

Preguntas más frecuentes sobre Azure Developer CLI