azd up werkstroom verkennen

Met de Azure Developer CLI (azd) kunt u toepassingsbronnen in Azure inrichten en implementeren met slechts één opdracht met behulp van azd up. Deze handleiding bevat een gedetailleerde uitsplitsing van azd up en hoe de verschillende fasen van deze werkstroomopdracht overeenkomen met de structuur van een azd sjabloon.

Volg mee met behulp van een sjabloon

In de volgende secties worden voorbeelden van de hello-azd sjabloon gebruikt om verschillende azd concepten en patronen te demonstreren. U kunt de volgende stappen volgen door de sjabloon op uw lokale computer te initialiseren:

azd init -t hello-azd

Ga voor meer informatie over hoe u aan de slag gaat met azd en de hello-azd-sjabloon naar het artikel Quickstart: Een Azure Developer CLI-sjabloon implementeren.

Essentiële concepten

Wanneer u met een azd sjabloon werkt, kunt u uw app-resources inrichten en implementeren in Azure met behulp van de azd up opdracht. Voer de opdracht uit vanuit een terminalvenster dat is geopend in de sjabloonmap:

azd up

azd up is zo ontworpen dat u de opdracht herhaaldelijk kunt uitvoeren tijdens het ontwikkelen van uw app en dat de nieuwe wijzigingen stapsgewijs worden geïmplementeerd. De opdracht initieert een krachtige werkstroom die in feite drie specifieke fasen verpakt:

1. Verpakking: Bereidt de toepassingscode en afhankelijkheden voor implementatie voor.
2. Inrichten: hiermee maakt en configureert u de benodigde Azure-resources die door de app zijn vereist met behulp van infrastructuur als codebestanden.
3. Implementatie: Implementeert de verpakte toepassing in de ingerichte Azure-resources.

U kunt elk van deze fasen ook afzonderlijk uitvoeren met behulp van hun respectieve opdracht, maar azd up biedt een handige wrapper om het algehele proces te stroomlijnen. Elke fase speelt een cruciale rol bij het garanderen van een soepel en geautomatiseerd implementatieproces. U kunt de azd up werkstroomfasen beïnvloeden met behulp van configuraties in het sjabloonbestand azure.yaml . In de volgende secties wordt elke fase uitgebreider besproken.

De verpakkingsfase

De verpakkingsfase is de eerste stap in de azd up werkstroom. Tijdens deze fase:

• De app-code wordt voorbereid voor implementatie. Afhankelijk van de programmeertaal waarmee de sjabloon-app is gebouwd, kan het verpakken betrekking hebben op het bouwen of compileren van de app, het bundelen van afhankelijkheden of het maken van implementatieartefacten zoals Docker-installatiekopieën.
• De azd sjabloonstructuur bevat doorgaans een src map waarin de toepassingscode zich bevindt. Bouw scripts of configuratiebestanden (zoals een Dockerfile) kunnen invloed hebben op de wijze waarop de toepassing moet worden verpakt.
• Het azure.yaml bestand bevat configuratietoewijzingen die aangeven azd waar uw app-code zich bevindt en welke taal wordt gebruikt, zodat azd deze op de juiste manier kan worden verpakt.
• Deze fase zorgt ervoor dat de toepassing een implementeerbare status heeft voordat u naar de volgende stap gaat.

U kunt het verpakkingsproces zelfstandig uitvoeren met behulp van de opdracht azd up buiten azd package.

azd package

Voorbeeld van verpakkingsconfiguraties

azd kan apps die zijn gebouwd met verschillende talen op verschillende manieren verpakken. Als uw app bijvoorbeeld gebruikmaakt van een in een container geplaatste benadering, kan de azd sjabloon een Dockerfile in de app-map src bevatten. In de verpakkingsfase wordt een Docker-image voor de app gebouwd op basis van dit bestand. Deze configuraties worden beheerd via het azure.yaml bestand.

Denk bijvoorbeeld aan de volgende projectstructuur en configuraties van de hello-azd starterssjabloon:

In de voorgaande afbeelding ziet u het azure.yaml bestand:

• Hiermee definieert u de code in de src map als een C#-app.
• Hiermee geeft u de locatie op van een Dockerfile die moet worden gebruikt om een containerimage van de app te bouwen.

Wanneer u azd up (of azd package) uitvoert, gebruikt de Azure Developer CLI deze combinatie van configuraties om de app-code in de src map te bouwen en te verpakken als een .NET-containerimage. Als een Dockerfile niet is geconfigureerd, azd kan de .NET-app ook worden verpakt met behulp van het standaard .NET-publicatieproces.

De voorzieningsfase

De inrichtingsfase maakt en configureert de vereiste Azure-resources voor uw app. Uw app kan bijvoorbeeld een Azure App Service-exemplaar vereisen om de app zelf te hosten en een Azure Storage-account voor het opslaan van geüploade bestanden. De inrichtingsfase maakt gebruik van IaC-bestanden (Infrastructure-as-Code) die zijn opgenomen in de sjabloon om de resources te definiëren.

Enkele belangrijke punten die u moet begrijpen over de inrichtingsfase zijn:

1. azd ondersteunt zowel Bicep als Terraform voor infrastructuur als codetaken.
2. Standaard worden bestanden met infrastructuur als code opgeslagen in de infra map, maar deze locatie kan worden aangepast.
3. azd zoekt naar een main.bicep of main.tf bestand om te fungeren als het hoofdorkestratiebestand voor het IaC-proces.

U kunt het inrichtingsproces ook zelfstandig uitvoeren buiten azd up met behulp van de azd provision opdracht:

azd provision

Voorbeeld van inrichtingsconfiguraties

Binnen de infra map definieert een main.bicep bestand doorgaans welke Azure-resources azd voor de app moeten worden gemaakt. Bekijk het volgende codefragment in main.bicep de hello-azd starterssjabloon:

// ...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

Met behulp van de voorgaande Bicep-code creëert azd de volgende resources:

• Een Azure Cosmos DB-exemplaar voor het opslaan van gegevens die zijn verzonden via de app
• Een Azure Storage-account voor het opslaan van geüploade afbeeldingen
• Een Azure Container App voor het hosten van de app

De implementatiefase

De implementatiefase is de laatste stap in de azd up werkstroom. Tijdens deze fase:

• De app-artefacten die tijdens de verpakkingsfase zijn gemaakt, worden geïmplementeerd in de ingerichte Azure-resources.
• azd maakt gebruik van configuratiebestanden in de sjabloon, zoals azure.yaml, om te bepalen hoe de app moet worden geïmplementeerd.
• Omgevingsvariabelen en verbindingsreeksen zijn geconfigureerd om ervoor te zorgen dat de app kan communiceren met de ingerichte resources.

U kunt het implementatieproces ook zelfstandig uitvoeren buiten azd up met het azd deploy commando:

azd deploy

Voorbeeld van implementatieconfiguraties

In het azure.yaml bestand kunt u opgeven welke service in uw project moet worden geïmplementeerd voor welke Azure-resource. Denk bijvoorbeeld aan de volgende configuraties voor de hello-azd starterssjabloon:

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

De voorgaande code geeft de opdracht azd om de artefacten te implementeren die zijn verpakt vanuit de code in de src map naar de containerapp code die is gemaakt tijdens de inrichtingsfase. U kunt ook meerdere services definiëren en elk toewijzen aan een andere host.

Conclusie

De azd up werkstroom stroomlijnt het proces van het implementeren van toepassingen in Azure door de verpakkings-, inrichtings- en implementatiefasen te automatiseren. Ontwikkelaars kunnen zorgen voor een consistent en efficiënt implementatieproces door zich aan de azd sjabloonstructuur te houden. Of u nu een eenvoudige web-app of een complexe microservicesarchitectuur implementeert, de azd up opdracht vereenvoudigt het traject van code naar de cloud.