Explorer le azd up flux de travail

Azure Developer CLI (azd) vous permet de provisionner et de déployer des ressources d’application sur Azure avec une seule commande à l’aide azd upde . Ce guide fournit une répartition détaillée de azd up et comment les différentes étapes de cette commande dans le flux de travail sont corrélées à la structure d’un modèle azd.

Suivez en utilisant un modèle

Les sections qui suivent utilisent des exemples du hello-azd modèle pour illustrer différents azd concepts et modèles. Vous pouvez suivre en initialisant le modèle sur votre ordinateur local :

azd init -t hello-azd

Pour plus d’informations sur la prise en main de azd et du modèle hello-azd, consultez l’article Quickstart : Déployer un modèle Azure Developer CLI.

Concepts essentiels

Lorsque vous utilisez un azd modèle, vous pouvez approvisionner et déployer vos ressources d’application sur Azure à l’aide de la azd up commande. Exécutez la commande à partir d’une fenêtre de terminal ouverte dans votre dossier de modèle :

azd up

azd up est conçu pour que vous puissiez exécuter à plusieurs reprises la commande au fur et à mesure que vous développez votre application, et les nouvelles modifications sont déployées de manière incrémentielle. La commande lance un flux de travail puissant qui encapsule essentiellement trois étapes spécifiques :

1. Empaquetage : prépare le code et les dépendances de l’application pour le déploiement.
2. Approvisionnement : crée et configure les ressources Azure nécessaires requises par l’application à l’aide de fichiers infrastructure-as-code.
3. Déploiement : déploie l’application empaquetée sur les ressources Azure approvisionnées.

Vous pouvez également exécuter chacune de ces étapes individuellement à l’aide de leur commande respective, mais azd up fournit un wrapper pratique pour simplifier le processus global. Chaque étape joue un rôle essentiel dans la garantie d’un processus de déploiement fluide et automatisé. Vous pouvez influencer les étapes du flux de travail azd up à l’aide de configurations dans le fichier azure.yaml de modèle. Les sections suivantes explorent chaque étape plus en détail.

Étape d’empaquetage

La phase d’empaquetage est la première étape du azd up flux de travail. Pendant cette phase :

• Le code de l’application est préparé pour le déploiement. Selon le langage de programmation avec lequel l’application modèle est créée, l’empaquetage peut impliquer la génération ou la compilation de l’application, le regroupement de dépendances ou la création d’artefacts de déploiement tels que des images Docker.
• La structure de azd modèle inclut généralement un src dossier où réside le code de l’application. Les scripts de génération ou les fichiers de configuration (tels qu’un fichier Dockerfile) peuvent influencer la façon dont l’application doit être empaquetée.
• Le azure.yaml fichier contient des mappages de configuration qui indiquent azd l’emplacement de vie de votre code d’application et le langage qu’il utilise afin de azd pouvoir le empaqueter correctement.
• Cette étape garantit que l’application est dans un état déployable avant de passer à l’étape suivante.

Vous pouvez exécuter le processus d’empaquetage indépendamment de azd up en utilisant la commande azd package :

azd package

Exemples de configurations d’empaquetage

azd peut empaqueter des applications créées avec différents langages de différentes manières. Par exemple, si votre application utilise une approche conteneurisée, le azd modèle peut inclure un Dockerfile dans le répertoire de l’application src . La phase d’empaquetage génère une image Docker pour l’application en fonction de ce fichier. Ces configurations sont gérées via le azure.yaml fichier.

Par exemple, tenez compte de la structure et des configurations de projet suivantes du hello-azd modèle de démarrage :

Dans l’image précédente, le azure.yaml fichier :

• Définit le code dans le src répertoire en tant qu’application C#.
• Spécifie l’emplacement d’un fichier Dockerfile à utiliser pour générer une image conteneur de l’application.

Lorsque vous exécutez azd up (ou azd package), Azure Developer CLI utilise cette combinaison de configurations pour générer et empaqueter le code de l’application dans le src répertoire en tant qu’image conteneur .NET. Si un fichier Dockerfile n’a pas été configuré, azd peut également empaqueter l’application .NET à l’aide du processus de publication .NET standard.

Étape d’approvisionnement

La phase d’approvisionnement crée et configure les ressources Azure requises pour votre application. Par exemple, votre application peut nécessiter une instance Azure App Service pour héberger l’application elle-même et un compte de stockage Azure pour contenir les fichiers chargés. L’étape d’approvisionnement utilise des fichiers IaC (Infrastructure-as-code) inclus dans le modèle pour définir les ressources.

Voici quelques points clés à comprendre sur la phase d’approvisionnement :

1. azd prend en charge à la fois Bicep et Terraform pour les tâches d’infrastructure en tant que code.
2. Par défaut, les fichiers infrastructure-as-code sont stockés dans le infra dossier, mais cet emplacement peut être personnalisé.
3. azd recherche un fichier main.bicep ou main.tf pour agir en tant que fichier d’orchestration principal du processus IaC.

Vous pouvez également exécuter le processus de configuration en dehors de azd up en utilisant la commande azd provision :

azd provision

Exemples de configurations d’approvisionnement

Dans le infra dossier, un main.bicep fichier définit généralement les ressources Azure qui azd doivent être créées pour l’application. Prenons l'exemple de l'extrait de code suivant de main.bicep dans le modèle de démarrage 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

À l’aide du code Bicep précédent, azd crée les ressources suivantes :

• Instance Azure Cosmos DB pour stocker les données envoyées via l’application
• Un compte Azure Storage pour stocker les images téléversées
• Application conteneur Azure pour héberger l’application

Étape de déploiement

L’étape de déploiement est la dernière étape du azd up flux de travail. Pendant cette phase :

• Les artefacts d’application créés pendant la phase d’empaquetage sont déployés sur les ressources Azure approvisionnées.
• azd utilise des fichiers de configuration dans le modèle, tels que azure.yaml, pour déterminer comment déployer l’application.
• Les variables d’environnement et les chaînes de connexion sont configurées pour garantir que l’application peut interagir avec les ressources approvisionnées.

Vous pouvez également exécuter le processus de déploiement en dehors de azd up à l'aide de la commande azd deploy.

azd deploy

Exemples de configurations de déploiement

À l'intérieur du fichier azure.yaml, vous pouvez spécifier quel service de votre projet doit être déployé sur quelle ressource Azure. Par exemple, tenez compte des configurations suivantes pour le hello-azd modèle de démarrage :

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

Le code précédent indique à azd de déployer les artefacts empaquetés à partir du code situé dans le dossier src vers containerapp, qui a été créé pendant l’étape de préparation. Vous pouvez également définir plusieurs services et mapper chacun à un hôte différent.

Conclusion

Le azd up flux de travail simplifie le processus de déploiement d’applications sur Azure en automatisant les phases d’empaquetage, d’approvisionnement et de déploiement. Les développeurs peuvent garantir un processus de déploiement cohérent et efficace en respectant la structure du azd modèle. Que vous déployiez une application web simple ou une architecture de microservices complexe, la azd up commande simplifie le parcours du code vers le cloud.