Explora el flujo de trabajo azd up

La CLI para desarrolladores de Azure (azd) permite aprovisionar e implementar recursos de aplicación en Azure con un solo comando mediante azd up. En esta guía se proporciona un desglose detallado de azd up y cómo las distintas fases de este comando de flujo de trabajo se correlacionan con la estructura de una azd plantilla.

Sigue el proceso con una plantilla

En las secciones anteriores se usan ejemplos de la hello-azd plantilla para mostrar varios azd conceptos y patrones. Puede continuar inicializando la plantilla en el equipo local:

azd init -t hello-azd

Para más información sobre cómo empezar a trabajar con azd y la plantilla, visite el artículo hello-azd de la CLI para desarrolladores de Azure.

Conceptos esenciales

Al trabajar con una azd plantilla, puede aprovisionar e implementar los recursos de la aplicación en Azure mediante el azd up comando . Ejecute el comando desde una ventana de terminal que esté abierta a la carpeta de plantilla:

azd up

azd up está diseñado para que pueda ejecutar repetidamente el comando a medida que desarrolla la aplicación y los nuevos cambios se implementan de forma incremental. El comando inicia un flujo de trabajo eficaz que básicamente incluye tres fases específicas:

1. Empaquetado: prepara el código de la aplicación y las dependencias para la implementación.
2. Aprovisionamiento: crea y configura los recursos de Azure necesarios que requiere la aplicación mediante archivos de infraestructura como código.
3. Implementación: implementa la aplicación empaquetada en los recursos de Azure aprovisionados.

También puede ejecutar cada una de estas fases individualmente mediante su comando respectivo, pero azd up proporciona un contenedor de conveniencia para simplificar el proceso general. Cada fase desempeña un papel fundamental para garantizar un proceso de implementación sin problemas y automatizado. Puede influir en las etapas del flujo de trabajo azd up utilizando las configuraciones del archivo de plantilla azure.yaml. En las secciones siguientes se explora cada fase con más detalle.

Fase de empaquetado

La fase de empaquetado es el primer paso del flujo de azd up trabajo. Durante esta fase:

• El código de la aplicación está preparado para la implementación. En función del lenguaje de programación con el que se construye la aplicación de plantilla, el empaquetado puede implicar la construcción o compilación de la aplicación, la agrupación de dependencias o la creación de artefactos de implementación como imágenes de Docker.
• La azd estructura de plantilla normalmente incluye una src carpeta donde reside el código de la aplicación. Los scripts de compilación o los archivos de configuración (como un Dockerfile) pueden influir en cómo se debe empaquetar la aplicación.
• El azure.yaml archivo contiene asignaciones de configuración que indican azd dónde reside el código de la aplicación y qué lenguaje usa para azd que pueda empaquetarlo correctamente.
• Esta fase garantiza que la aplicación se encuentra en un estado implementable antes de pasar al paso siguiente.

Puede ejecutar el proceso de empaquetado de forma independiente de azd up utilizando el comando azd package.

azd package

Configuraciones de empaquetado de ejemplo

azd puede empaquetar aplicaciones creadas con diferentes lenguajes de diferentes maneras. Por ejemplo, si la aplicación usa un enfoque contenedorizado, azd plantilla podría incluir un Dockerfile en el directorio de la aplicación src. La fase de empaquetado compila una imagen de Docker para la aplicación en función de este archivo. Estas configuraciones se administran a través del azure.yaml archivo .

Por ejemplo, considere la siguiente estructura de proyecto y configuraciones de la hello-azd plantilla de inicio:

En la imagen anterior, el azure.yaml archivo:

• Define el código en el src directorio como una aplicación de C#.
• Especifica la ubicación de un Dockerfile que se va a usar para compilar una imagen de contenedor de la aplicación.

Cuando se ejecuta azd up (o azd package), la CLI para desarrolladores de Azure usa esta combinación de configuraciones para compilar y empaquetar el código de la aplicación en el src directorio como una imagen de contenedor de .NET. Si no se ha configurado un Dockerfile, azd también podría empaquetar la aplicación .NET mediante el proceso de publicación estándar de .NET.

Fase de aprovisionamiento

La fase de aprovisionamiento crea y configura los recursos de Azure necesarios para la aplicación. Por ejemplo, la aplicación podría requerir una instancia de Azure App Service para hospedar la propia aplicación y una cuenta de Azure Storage para almacenar los archivos cargados. La fase de aprovisionamiento usa archivos de infraestructura como código (IaC) incluidos en la plantilla para definir los recursos.

Algunos puntos clave que se deben comprender sobre la fase de aprovisionamiento incluyen:

1. azd admite tanto Bicep como Terraform para tareas relacionadas con la gestión de infraestructura como código.
2. De forma predeterminada, los archivos de infraestructura como código se almacenan en la infra carpeta, pero esta ubicación se puede personalizar.
3. azd busca un archivo main.bicep o main.tf que actúe como el archivo de orquestación principal para el proceso IaC.

También puede ejecutar el proceso de aprovisionamiento por su cuenta fuera de azd up mediante el azd provision comando :

azd provision

Configuraciones de aprovisionamiento de ejemplo

Dentro de la infra carpeta , un main.bicep archivo generalmente define los recursos de Azure que azd deben crearse para la aplicación. Tenga en cuenta el siguiente fragmento de código de main.bicep en la plantilla de inicio hello-azd:

// ...omitted code for other resource configurations

// Create an Azure Cosmos DB account
module cosmos 'app/cosmos.bicep' = {
  name: 'cosmos'
  scope: rg
  params: {
    userPrincipalId: principalId
    managedIdentityId: identity.outputs.principalId
  }
}

// Create a storage account
module storage './core/storage/storage-account.bicep' = {
  name: 'storage'
  scope: rg
  params: {
    name: !empty(storageAccountName) ? storageAccountName : '${abbrs.storageStorageAccounts}${resourceToken}'
    location: location
    tags: tags
    containers: [
      { name: 'attachments' }
    ]
  }
}

// Container apps environment and registry
module containerAppsEnv './core/host/container-apps.bicep' = {
  name: 'container-apps'
  scope: rg
  params: {
    name: 'app'
    containerAppsEnvironmentName: !empty(containerAppsEnvName) ? containerAppsEnvName : '${abbrs.appManagedEnvironments}${resourceToken}'
    containerRegistryName: !empty(containerRegistryName) ? containerRegistryName : '${abbrs.containerRegistryRegistries}${resourceToken}'
    location: location
  }
}

// ...omitted code for other resource configurations

Con el código de Bicep anterior, azd crea los siguientes recursos:

• Una instancia de Azure Cosmos DB para almacenar los datos enviados a través de la aplicación
• Una cuenta de Azure Storage para almacenar imágenes cargadas
• Una aplicación de contenedor de Azure para hospedar la aplicación

La fase de implementación

La fase de implementación es el paso final del flujo de azd up trabajo. Durante esta fase:

• Los artefactos de la aplicación creados durante la fase de empaquetado se implementan en los recursos de Azure aprovisionados.
• azd usa archivos de configuración en la plantilla, como azure.yaml, para determinar cómo implementar la aplicación.
• Las variables de entorno y las cadenas de conexión están configuradas para asegurarse de que la aplicación puede interactuar con los recursos aprovisionados.

También puede ejecutar el proceso de implementación por su cuenta fuera de azd up mediante el azd deploy comando :

azd deploy

Configuraciones de implementación de ejemplo

Dentro del azure.yaml archivo, puede especificar qué servicio del proyecto se debe implementar en qué recurso de Azure. Por ejemplo, considere las siguientes configuraciones para la hello-azd plantilla de inicio:

metadata:
  template: hello-azd-dotnet
name: azd-starter
services:
  aca:
    project: ./src # The location of the service source code
    language: csharp
    host: containerapp # The provisioned resource to deploy the service to
    docker:
      path: ./Dockerfile

El código anterior indica a azd que implemente los artefactos empaquetados desde el código de src la carpeta en containerapp que fue creado durante la fase de aprovisionamiento. También puede definir varios servicios y asignar cada uno a un host diferente.

Conclusión

El azd up flujo de trabajo simplifica el proceso de implementación de aplicaciones en Azure mediante la automatización de las fases de empaquetado, aprovisionamiento e implementación. Los desarrolladores pueden garantizar un proceso de implementación coherente y eficaz mediante la adhesión a la estructura de plantillas azd . Tanto si va a implementar una aplicación web sencilla como una arquitectura compleja de microservicios, el azd up comando simplifica el recorrido desde el código a la nube.