Självstudie: Distribuera miljöer i CI/CD med hjälp av GitHub- och Azure Deployment Environments

I den här handledningen lär du dig att integrera Azure Deployment Environments i din CI/CD-pipeline. Du kan använda valfri GitOps-provider som stöder CI/CD, till exempel GitHub Actions, Azure Arc, GitLab eller Jenkins.

Kontinuerlig integrering och kontinuerlig leverans (CI/CD) är en metod för programvaruutveckling som hjälper teamen att automatisera processen med att skapa, testa och distribuera programvaruändringar. MED CI/CD kan du släppa programändringar oftare och med större säkerhet.

Du använder ett arbetsflöde som har tre grenar: main, dev och test.

• Huvudgrenen betraktas alltid som produktion.
• Du skapar funktionsgrenar från huvudgrenen .
• Du skapar pull-begäranden för att sammanfoga funktionsgrenar till main.

Arbetsflödet i den här handledningen är ett förenklat exempel. Verkliga arbetsflöden kan vara mer komplexa.

Innan du påbörjar den här självstudien kan du bekanta dig med komponenter och begrepp för distributionsmiljöer genom att granska viktiga begrepp för Azure-distributionsmiljöer.

I den här tutorialen lär du dig följande:

• Skapa och konfigurera ett utvecklingscenter
• Skapa ett nyckelvalv
• Skapa och konfigurera en GitHub-lagringsplats
• Ansluta katalogen till utvecklingscentret
• Konfigurera distributionsidentiteter
• Konfigurera GitHub-miljöer
• Test the CI/CD pipeline

Förutsättningar

Produkt	Requirements
Blått	- An Azure subscription. – Ägarbehörigheter för Azure-prenumerationen. - Azure CLI installerad.
Git	– Ett GitHub-konto. - Git installed.

1. Skapa och konfigurera ett utvecklingscenter

I det här avsnittet skapar du ett Utvecklingscenter för Azure Deployment Environments och ett projekt med tre miljötyper: Dev, Test och Prod.

• Miljötypen Prod innehåller den enskilda produktionsmiljön.
• En ny miljö skapas i Dev för varje funktionsgren.
• En ny miljö skapas i Test för varje pull-begäran.

1.1 Konfigurera Azure CLI

Börja genom att logga in på Azure. Kör följande kommando och följ anvisningarna för att slutföra autentiseringsprocessen:

az login

Installera sedan Azure devcenter-tillägget för Azure CLI:

az extension add --name devcenter --upgrade

Nu när det aktuella tillägget har installerats registrerar du Microsoft.DevCenter namnområdet:

az provider register --namespace Microsoft.DevCenter

Tips/Råd

I den här självstudien sparar du flera värden som miljövariabler som ska användas senare. Du kanske också vill registrera dessa värden någon annanstans för att säkerställa att de är tillgängliga när du behöver dem.

Hämta ditt användar-ID och ange det till en miljövariabel för senare:

MY_AZURE_ID=$(az ad signed-in-user show --query id -o tsv)

Hämta prenumerations-ID:t för din aktuella prenumeration:

AZURE_SUBSCRIPTION_ID=$(az account show --query id --output tsv)

Retrieve the tenant ID for your current tenant:

AZURE_TENANT_ID=$(az account show --query tenantId --output tsv)

Ange följande miljövariabler:

LOCATION="eastus"
AZURE_RESOURCE_GROUP=<resourceGroupName>
AZURE_DEVCENTER=<devcenterName>
AZURE_PROJECT=<projectName>
AZURE_KEYVAULT=<keyVaultName>

Anmärkning

Du måste använda ett globalt unikt nyckelvalvnamn. Annars kan du få följande fel:

Code: VaultAlreadyExists Message: The vault name 'mykeyvaultname' is already in use. Vault names are globally unique so it is possible that the name is already taken.

1.2 Skapa ett utvecklingscenter

Ett utvecklingscenter är en samling projekt och miljöer som har liknande inställningar. Dev Centers ger åtkomst till en katalog med mallar och artefakter som kan användas för att skapa miljöer. Dev centers ger också ett sätt att hantera åtkomst till miljöer och projekt.

Skapa en resursgrupp:

az group create \
  --name $AZURE_RESOURCE_GROUP \
  --location $LOCATION

Skapa ett utvecklingscenter:

az devcenter admin devcenter create \
  --name $AZURE_DEVCENTER \
  --identity-type SystemAssigned \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION

Föregående kommando matar ut JSON. Spara värdena för id och identity.principalId som miljövariabler som ska användas senare:

AZURE_DEVCENTER_ID=<id>
AZURE_DEVCENTER_PRINCIPAL_ID=<identity.principalId>

1.3 Assign the dev center identity owner role on the subscription

Ett utvecklingscenter behöver behörigheter för att tilldela roller för prenumerationer som är associerade med miljötyper.

För att minska onödig komplexitet använder du i den här självstudien en enda prenumeration för utvecklingscentret och alla miljötyper. I praktiken skulle dev center- och måldistributionsprenumerationer förmodligen vara separata prenumerationer med olika principer som tillämpas.

az role assignment create \
  --scope /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --role Owner \
  --assignee-object-id $AZURE_DEVCENTER_PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal

1.4 Skapa miljötyperna

På utvecklingscenternivå definierar miljötyper de miljöer som utvecklingsteam kan skapa, till exempel utveckling, testning, sandbox-miljö, förproduktion och produktion.

Skapa tre nya miljötyper: Dev, Test och Prod:

az devcenter admin environment-type create \
  --name Dev \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER

az devcenter admin environment-type create \
  --name Test \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER

az devcenter admin environment-type create \
  --name Prod \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER

1.5 Skapa ett projekt

Ett projekt är åtkomstpunkten för utvecklingsteamet. Varje projekt är associerat med ett utvecklingscenter.

Skapa ett projekt:

az devcenter admin project create \
  --name $AZURE_PROJECT \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --dev-center-id $AZURE_DEVCENTER_ID

Föregående kommando matar ut JSON. Spara värdet id som en miljövariabel som ska användas senare:

AZURE_PROJECT_ID=<id>

Tilldela dig själv rollen DevCenter-projektadministratör i projektet:

az role assignment create \
  --scope "$AZURE_PROJECT_ID" \
  --role "DevCenter Project Admin" \
  --assignee-object-id $MY_AZURE_ID \
  --assignee-principal-type User

1.6 Skapa projektmiljötyper

På projektnivå anger plattformstekniker vilka miljötyper som är lämpliga för utvecklingsteamet.

Skapa en ny projektmiljötyp för var och en av de miljötyper som du skapade i utvecklingscentret:

az devcenter admin project-environment-type create \
  --name Dev \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled

az devcenter admin project-environment-type create \
  --name Test \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled

az devcenter admin project-environment-type create \
  --name Prod \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled

Skapa ett nyckelvalv

I det här avsnittet skapar du ett nytt nyckelvalv. Du använder det här nyckelvalvet senare i självstudien för att spara en personlig åtkomsttoken från GitHub.

az keyvault create \
  --name $AZURE_KEYVAULT \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --enable-rbac-authorization true

id Spara återigen från föregående kommandos JSON-utdata som en miljövariabel:

AZURE_KEYVAULT_ID=<id>

Ge dig själv rollen Key Vault-administratör i det nya nyckelvalvet:

az role assignment create \
  --scope $AZURE_KEYVAULT_ID \
  --role "Key Vault Administrator" \
  --assignee-object-id $MY_AZURE_ID \
  --assignee-principal-type User

Assign the dev center's identity the role of Key Vault Secrets User:

az role assignment create \
  --scope $AZURE_KEYVAULT_ID \
  --role "Key Vault Secrets User" \
  --assignee-object-id $AZURE_DEVCENTER_PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal

3. Skapa och konfigurera en GitHub-lagringsplats

I det här avsnittet skapar du en ny GitHub-lagringsplats för att lagra en katalog. Azure Deployment Environments stöder både GitHub- och Azure DevOps-lagringsplatser. I den här handledningen använder du GitHub.

3.1 Skapa en GitHub-lagringsplats

I det här steget skapar du en ny lagringsplats i ditt GitHub-konto som har en fördefinierad katalogstruktur, grenar och filer. Dessa objekt genereras från en exempelmalllagringsplats.

1. Generera en ny GitHub-lagringsplats från exempelmallen:

   

2. Om du inte har ett betalt GitHub-konto anger du lagringsplatsen till Offentlig.

3. Välj Skapa lagringsplats.

3.2 Skydda lagringsplatsens huvudgren

Du kan skydda viktiga grenar genom att ange regler för grenskydd. Protection rules define whether collaborators can delete a branch or force push to the branch. They also set requirements for pushes to the branch, such as passing status checks or enforcing a linear commit history.

Anmärkning

Skyddade grenar är tillgängliga på offentliga lagringsplatser med GitHub Free och GitHub Free för organisationer och i offentliga och privata lagringsplatser med GitHub Pro, GitHub Team, GitHub Enterprise Cloud och GitHub Enterprise Server. Mer information finns i GitHub-planer.

1. Om den inte redan är öppen går du till huvudsidan för lagringsplatsen.

2. Välj Inställningar i menyn överst i fönstret:

   

3. I avsnittet Kod och automatisering i det vänstra sidofältet väljer du Grenar:

   

4. Under Grenskyddsregler väljer du Lägg till grenregelsamling:

   

5. På sidan Regleruppsättning för ny gren i Regleruppsättningens namn anger du CI-CD-tutorial-ruleset:

   

6. Under Målgrenar väljer du Lägg till mål och väljer sedan antingen Inkludera standardgren eller Inkludera alla grenar:

   

7. Under Grenregler väljer du Kräv en pull-begäran innan sammanslagning:

   

8. Du kan också aktivera fler skyddsregler.

9. Välj Skapa.

3.3 Konfigurera lagringsplatsvariabler

1. I avsnittet Säkerhet i sidofältet väljer du Hemligheter och variabler och sedan Åtgärder:

   

2. Välj fliken Variabler .

3. För varje objekt i följande tabell:

   1. Välj Ny lagringsplatsvariabel.
   2. I fältet Namn anger du variabelnamnet.
   3. I fältet Värde anger du det värde som beskrivs i tabellen.
   4. Välj Lägg till variabel.

   Variabelnamn	Variabelvärde
   AZURE_DEVCENTER	Ditt dev center-namn
   AZURE_PROJECT	Projektnamnet
   AZURE_KATALOG	Ställ in på Miljöer
   AZURE_CATALOG_ITEM	Ställ in på FunctionApp
   AZURE_SUBSCRIPTION_ID	Ditt Azure-prenumerations-ID
   AZURE_TENANT_ID	Ditt Azure-klient-ID

   

3.4 Skapa en personlig Åtkomsttoken för GitHub

Skapa sedan en detaljerad personlig åtkomsttoken för att aktivera ditt Azure Deployment Environments dev center för att ansluta till lagringsplatsen och använda miljökatalogen.

Anmärkning

Du kan lämna feedback om detaljerade personliga åtkomsttoken i feedbackdiskussionen.

1. I det övre högra hörnet på en sida på GitHub.com väljer du ditt profilfoto och väljer sedan Inställningar.

2. I det vänstra sidofältet väljer du Inställningar för utvecklare.

3. I det vänstra sidofältet går du till Personliga åtkomsttoken, väljer Detaljerade token och väljer sedan Generera ny token:

   

4. På sidan Ny detaljerad personlig åtkomsttoken under Tokennamn anger du ett namn för token.

5. Under Förfallodatum väljer du ett förfallodatum för token.

6. Under Resursägare väljer du ditt GitHub-användarnamn.

7. Under Åtkomst till lagringsplats väljer du Endast utvalda lagringsplatser. Under Valda lagringsplatser söker du efter och väljer den lagringsplats som du skapade:

   

8. Under Behörigheter väljer du Lagringsplatsbehörigheter och ändrar sedan Innehållet till Skrivskyddat:

   

9. Välj Generera token.

10. Kopiera och spara din personliga åtkomsttoken. Du kommer inte att kunna visa den igen.

3.5 Spara din personliga åtkomsttoken till nyckelvalvet

Spara sedan den personliga åtkomsttoken som en nyckelvalvshemlighet med namnet pat:

az keyvault secret set \
    --name pat \
    --vault-name $AZURE_KEYVAULT \
    --value <personalAccessToken>

4. Anslut katalogen till utvecklingscentret

I Azure Deployment Environments är en katalog en lagringsplats som innehåller en uppsättning miljödefinitioner. Katalogobjekt består av en IaC-mall (infrastructure-as-code) och en miljöfil som fungerar som ett manifest. Mallen definierar miljön och miljöfilen innehåller metadata om mallen. Utvecklingsteam använder miljödefinitioner från katalogen för att skapa miljöer.

Mallen som du använde för att skapa din GitHub-lagringsplats innehåller en katalog i mappen Miljöer .

Lägg till katalogen i utvecklingscentret

I följande kommando ersätter du < Organization/Repository > med github-organisationen och lagringsplatsens namn:

az devcenter admin catalog create \
    --name Environments \
    --resource-group $AZURE_RESOURCE_GROUP \
    --dev-center $AZURE_DEVCENTER \
    --git-hub path="/Environments" branch="main" secret-identifier="https://$AZURE_KEYVAULT.vault.azure.net/secrets/pat" uri="https://github.com/< Organization/Repository >.git"

5. Konfigurera distributionsidentiteter

OpenID Connect med GitHub Actions är en autentiseringsmetod som använder kortlivade token för att ge förstärkt säkerhet. Det är det rekommenderade sättet att autentisera GitHub Actions till Azure.

You can also authenticate a service principal directly by using a secret, but that's out of scope for this tutorial.

5.1 Generate deployment identities

1. Registrera Microsoft Entra-program och tjänstens huvudprincipaler för alla tre miljötyper.

   Skapa Microsoft Entra-programmet för Dev:

   az ad app create --display-name "$AZURE_PROJECT-Dev"
   

   Det här kommandot matar ut JSON med ett id som du använder när du skapar federerade autentiseringsuppgifter med Graph API och ett appId (kallas även för ett klient-ID).

   Ange följande miljövariabler:

   DEV_AZURE_CLIENT_ID=<appId>
   DEV_APPLICATION_ID=<id>
   

   Upprepa de här stegen för Test:

   az ad app create --display-name "$AZURE_PROJECT-Test"
   

   TEST_AZURE_CLIENT_ID=<appId>
   TEST_APPLICATION_ID=<id>
   

   Upprepa stegen igen för Prod:

   az ad app create --display-name "$AZURE_PROJECT-Prod"
   

   PROD_AZURE_CLIENT_ID=<appId>
   PROD_APPLICATION_ID=<id>
   

2. Skapa ett huvudnamn för tjänsten för varje program.

   Kör följande kommando för att skapa ett nytt huvudnamn för tjänsten för Dev:

    az ad sp create --id $DEV_AZURE_CLIENT_ID
   

   Det här kommandot genererar JSON-utdata med en annan id som ska användas i nästa steg.

   Ange följande miljövariabel:

   DEV_SERVICE_PRINCIPAL_ID=<id>
   

   Upprepa de här stegen för Test:

    az ad sp create --id $TEST_AZURE_CLIENT_ID
   

   TEST_SERVICE_PRINCIPAL_ID=<id>
   

   Upprepa stegen igen för Prod:

    az ad sp create --id $PROD_AZURE_CLIENT_ID
   

   PROD_SERVICE_PRINCIPAL_ID=<id>
   

3. Kör följande kommandon för att skapa en ny federerad identitetsautentiseringsuppgift för varje Microsoft Entra-program.

   I vart och ett av följande tre kommandon ersätter du < Organization/Repository > med din GitHub-organisation och lagringsplatsnamn.

   Skapa den federerade identitetsautentiseringsuppgiften för Dev:

   az rest --method POST \
       --uri "https://graph.microsoft.com/beta/applications/$DEV_APPLICATION_ID/federatedIdentityCredentials" \
       --body '{"name":"ADEDev","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Dev","description":"Dev","audiences":["api://AzureADTokenExchange"]}'
   

   Skapa autentiseringsuppgifterna för Test:

   az rest --method POST \
       --uri "https://graph.microsoft.com/beta/applications/$TEST_APPLICATION_ID/federatedIdentityCredentials" \
       --body '{"name":"ADETest","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Test","description":"Test","audiences":["api://AzureADTokenExchange"]}'
   

   Skapa autentiseringsuppgifterna för Prod:

   az rest --method POST \
       --uri "https://graph.microsoft.com/beta/applications/$PROD_APPLICATION_ID/federatedIdentityCredentials" \
       --body '{"name":"ADEProd","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Prod","description":"Prod","audiences":["api://AzureADTokenExchange"]}'
   

5.2 Assign roles to deployment identities

1. Tilldela varje distributionsidentitet rollen Läsare i projektet:

   az role assignment create \
       --scope "$AZURE_PROJECT_ID" \
       --role Reader \
       --assignee-object-id $DEV_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

   az role assignment create \
       --scope "$AZURE_PROJECT_ID" \
       --role Reader \
       --assignee-object-id $TEST_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

   az role assignment create \
       --scope "$AZURE_PROJECT_ID" \
       --role Reader \
       --assignee-object-id $PROD_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

2. Tilldela användarrollen Distributionsmiljöer till motsvarande miljötyp för varje distributionsidentitet:

   az role assignment create \
       --scope "$AZURE_PROJECT_ID/environmentTypes/Dev" \
       --role "Deployment Environments User" \
       --assignee-object-id $DEV_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

   az role assignment create \
       --scope "$AZURE_PROJECT_ID/environmentTypes/Test" \
       --role "Deployment Environments User" \
       --assignee-object-id $TEST_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

   az role assignment create \
       --scope "$AZURE_PROJECT_ID/environmentTypes/Prod" \
       --role "Deployment Environments User" \
       --assignee-object-id $PROD_SERVICE_PRINCIPAL_ID \
       --assignee-principal-type ServicePrincipal
   

6. Konfigurera GitHub-miljöer

Med GitHub-miljöer kan du konfigurera miljöer med skyddsregler och hemligheter. A workflow job that references an environment must follow any protection rules for the environment before running or accessing the environment's secrets.

Skapa dev-, test- och prod-miljöer som mappar till miljötyperna i Azure Deployment Environments-projektet.

Anmärkning

Miljöer, miljöhemligheter och miljöskyddsregler är tillgängliga på offentliga lagringsplatser för alla produkter. För åtkomst till miljöer, miljöhemligheter och distributionsgrenar i privata eller interna lagringsplatser måste du använda GitHub Pro, GitHub Team eller GitHub Enterprise. För åtkomst till andra miljöskyddsregler i privata eller interna lagringsplatser måste du använda GitHub Enterprise. Mer information finns i GitHub-planer.

6.1 Skapa Dev-miljön

1. I GitHub går du till huvudsidan för lagringsplatsen.

2. Under namnet på lagringsplatsen väljer du Inställningar. Om du inte kan se fliken Inställningar väljer du listrutan ... och väljer sedan Inställningar.

3. I det vänstra sidofältet väljer du Miljöer.

4. Välj Ny miljö och ange Dev som miljönamn och välj sedan Konfigurera miljö:

   

5. Under Miljöhemligheter väljer du Lägg till miljöhemlighet och anger sedan AZURE_CLIENT_ID i rutan Namn .

   

6. I rutan Värde anger du klient-ID:t (appId) för Microsoft Entra-appen Dev som du skapade tidigare (sparad som miljövariabeln $DEV_AZURE_CLIENT_ID).

   

7. Välj Add secret (Lägg till hemlighet).

6.2 Skapa testmiljön

Gå tillbaka till huvudmiljösidan genom att välja Miljöer i det vänstra sidofältet.

1. Välj Ny miljö, ange Test för miljönamnet och välj sedan Konfigurera miljö.

2. Under Miljöhemligheter väljer du Lägg till miljöhemlighet och anger sedan AZURE_CLIENT_ID i rutan Namn .

3. I rutan Värde anger du klient-ID :t (appId) för testappen Microsoft Entra som du skapade tidigare (sparad som $TEST_AZURE_CLIENT_ID miljövariabel).

4. Välj Add secret (Lägg till hemlighet).

6.3 Skapa Prod-miljön

Gå tillbaka till huvudmiljösidan igen genom att välja Miljöer i det vänstra sidofältet.

1. Välj Ny miljö, ange Prod som miljönamn och välj sedan Konfigurera miljö.

2. Under Miljöhemligheter väljer du Lägg till miljöhemlighet och anger sedan AZURE_CLIENT_ID i rutan Namn .

3. I rutan Värde anger du klient-ID :t (appId) för Prod Microsoft Entra-appen som du skapade tidigare (sparad som $PROD_AZURE_CLIENT_ID miljövariabeln).

4. Välj Add secret (Lägg till hemlighet).

Ange sedan dig själv som en nödvändig granskare för den här miljön. När man försöker distribuera till Prod väntar GitHub Actions på ett godkännande innan det startar. Medan ett jobb väntar på godkännande har det statusen Väntar. Om ett jobb inte godkänns inom 30 dagar misslyckas det automatiskt.

Mer information om miljöer och nödvändiga godkännanden finns i Använda miljöer för distribution.

1. Välj Nödvändiga granskare.

2. Sök efter och välj ditt GitHub-användarnamn. Du kan ange upp till sex personer eller team. Endast en av de nödvändiga granskarna behöver godkänna jobbet för att det ska fortsätta.

3. Välj Spara skyddsregler.

Konfigurera slutligen main som distributionsgren:

1. I listan Distributionsgrenar och taggar väljer du Valda grenar och taggar.

2. Välj Lägg till distributionsgren eller taggregel, se till att Referenstyp: Gren är markerad och ange sedan main i rutan Namnmönster .

3. Välj Lägg till regel.

7. Test the CI/CD pipeline

I det här avsnittet gör du några ändringar i lagringsplatsen och testar CI/CD-pipelinen.

7.1 Klona lagringsplatsen

1. I Git Bash använder du cd för att växla till en mapp där du vill klona lagringsplatsen lokalt.

2. Klona lagringsplatsen. Se till att ersätta < Organization/Repository > i följande kommando med din GitHub-organisation och lagringsplatsnamn.

   git clone https://github.com/< Organization/Repository >.git
   

3. Navigera till den klonade katalogen:

   cd <repository>
   

4. Skapa en ny gren och publicera den via fjärranslutning:

   git checkout -b feature1
   

   git push -u origin feature1
   

   En ny miljö som är specifik för den här grenen skapas i Azure.

5. I GitHub går du till huvudsidan för din nyligen skapade lagringsplats.

6. Under namnet på lagringsplatsen väljer du Åtgärder:

   You should see a new Create Environment workflow running.

7.2 Ändra koden

1. Öppna den lokalt klonade lagringsplatsen i Visual Studio Code.

2. I mappen ADE.Tutorial gör en ändring i en fil.

3. Save your change.

7.3 Skicka ändringarna för att uppdatera systemmiljön

1. Stage your changes and push to the feature1 branch:

   git add .
   git commit -m '<commit message>'
   git push
   

2. On your repository's Actions page, you see a new Update Environment workflow running.

7.4 Skapa en pull-begäran

1. Skapa en GitHub-pullbegäran main <- feature1.

2. På sidan Åtgärder på lagringsplatsen ser du att ett nytt arbetsflöde har startats för att skapa en miljö som är specifik för pull-begäran. Testmiljötypen används.

7.5 Sammanfoga pull-begäran

1. I GitHub går du till pull-begäran som du skapade.

2. Merge the pull request.

   Dina ändringar publiceras i produktionsmiljön och förgrenings- och pull-begärandemiljöerna tas bort.

Rensa resurser

Om du inte planerar att använda någon av de resurser som du har skapat tar du bort dem så att du inte debiteras ytterligare avgifter. Om du har distribuerat exempelprogrammet i en annan resursgrupp kanske du vill upprepa följande steg.

Så här tar du bort resurser med hjälp av Azure Portal:

1. Välj menyknappen i det övre vänstra hörnet och välj sedan Resursgrupper.

2. I listan väljer du den resursgrupp som du skapade.

3. Välj Ta bort resursgrupp.

4. Ange resursgruppsnamnet. Välj sedan ta bort.

Om du vill ta bort resurser med hjälp av Azure CLI anger du följande kommando:

az group delete --name <my-dev-center-rg>

Kom ihåg att om du tar bort resursgruppen tas alla resurser i den bort.

Relaterat innehåll

• Skapa och komma åt en miljö med hjälp av Azure CLI-
• Fullständiga kommandolistor finns i Azure CLI-dokumentationen för Microsoft Dev Box och Azure Deployment Environments