Övning – Konfigurera din miljö

  • 20 minuter

I det här avsnittet ser du till att din Azure DevOps-organisation har konfigurerats för att slutföra resten av den här modulen. Du skapar även de Azure App Service-miljöer som du ska distribuera till.

För att uppfylla dessa mål:

  • Lägg till en användare för att säkerställa att Azure DevOps kan ansluta till din Azure-prenumeration.
  • Konfigurera ett Azure DevOps-projekt för den här modulen.
  • I Azure Boards flyttar du arbetsobjektet för den här modulen till kolumnen Doing .
  • Kontrollera att projektet har konfigurerats lokalt så att du kan skicka ändringar till pipelinen.
  • Skapa Azure App Service-miljöer med hjälp av Azure CLI i Azure Cloud Shell.
  • Skapa pipelinevariabler som definierar namnen på dina App Service-miljöer.
  • Skapa en tjänstanslutning som gör det möjligt för Azure Pipelines att få säker åtkomst till din Azure-prenumeration.
  • Utför en första distribution.

Lägga till en användare i Azure DevOps

För att slutföra den här modulen behöver du en egen Azure-prenumeration. Du kan komma igång med Azure kostnadsfritt.

Även om du inte behöver en Azure-prenumeration för att fungera med Azure DevOps använder du här Azure DevOps för att distribuera till resurser som finns i din Azure-prenumeration. För att förenkla processen använder du samma Microsoft-konto för att logga in på både din Azure-prenumeration och din Azure DevOps-organisation.

Om du använder olika Microsoft-konton för att logga in på Azure och Azure DevOps lägger du till en användare i din DevOps-organisation under det Microsoft-konto som du använder för att logga in på Azure. Mer information finns i Lägga till användare i din organisation eller projekt. När du lägger till användaren väljer du åtkomstnivån Grundläggande.

Logga sedan ut från Azure DevOps och logga in igen under det Microsoft-konto som du använder för att logga in på din Azure-prenumeration.

Hämta Azure DevOps-projektet

Här ser du till att din Azure DevOps-organisation har konfigurerats för att slutföra resten av den här modulen. Du konfigurerar det genom att köra en mall som skapar ett projekt i Azure DevOps.

Modulerna i den här utbildningsvägen är en del av en utveckling. Du följer Tailspin-webbteamet genom deras DevOps-resa. I utbildningssyfte har varje modul ett associerat Azure DevOps-projekt.

Kör mallen

Kör en mall som konfigurerar din Azure DevOps-organisation.

Kör mallen

På webbplatsen Azure DevOps Demo Generator kör du mallen genom att följa dessa steg:

  1. Välj Logga in och godkänn användningsvillkoren.

  2. På sidan Skapa nytt projekt väljer du din Azure DevOps-organisation. Ange sedan ett projektnamn, till exempel Space Game – web – Distributionsmönster.

    Skärmbild som visar hur du skapar ett projekt via Azure DevOps Demo Generator.

  3. Välj Ja, jag vill förgrena den här lagringsplatsen. Välj sedan Auktorisera.

  4. Välj Skapa projekt.

    Det tar en stund att köra mallen.

  5. Välj Navigera till projekt för att gå till projektet i Azure DevOps.

Viktig

Sidan Rensa din Azure DevOps-miljö i den här modulen innehåller viktiga rensningssteg. Genom att rensa upp ser du till att du inte får slut på kostnadsfria byggminuter. Följ rensningsstegen även om du inte slutför den här modulen.

Ange projektets synlighet

Ursprungligen är din fork av Space Game-repositoriet på GitHub inställt på offentlig medan projektet som skapats av Azure DevOps-mallen är inställt på privat. En offentlig lagringsplats på GitHub kan nås av vem som helst, medan en privat lagringsplats endast är tillgänglig för dig och de personer som du väljer att dela den med. På samma sätt ger offentliga projekt i Azure DevOps skrivskyddad åtkomst till icke-autentiserade användare, medan privata projekt kräver att användarna beviljas åtkomst och autentiseras för att få åtkomst till tjänsterna.

För närvarande är det inte nödvändigt att ändra någon av dessa inställningar i den här modulen. För dina personliga projekt måste du dock fastställa den synlighet och åtkomst som du vill bevilja andra. Om projektet till exempel är öppen källkod kan du välja att göra både din GitHub-lagringsplats och ditt Azure DevOps-projekt offentliga. Om projektet är proprietärt skulle du vanligtvis göra både din GitHub-lagringsplats och ditt Azure DevOps-projekt privata.

Senare kan följande resurser vara användbara för att avgöra vilket alternativ som är bäst för projektet:

Flytta arbetsobjektet till Pågående

I den här delen tilldelar du dig själv ett arbetsobjekt i Azure Boards som relaterar till den här modulen. Du flyttar också arbetsobjektet till tillståndet Doing. I praktiken skulle ert team skapa arbetsobjekt i början av varje sprinteller arbetsiteration.

Genom att tilldela arbete på det här sättet får du en checklista att arbeta från. Det ger ditt team insyn i vad du arbetar med och hur mycket arbete som återstår. Det hjälper också teamet att tillämpa gränser för pågående arbete (WIP) så att teamet inte tar på sig för mycket arbete samtidigt.

Kom ihåg att teamet har bestämt sig för de här viktigaste problemen för den aktuella sprinten:

Skärmbild av Azure Boards som visar uppgifter för den här sprinten.

Observera

I en Azure DevOps-organisation numreras arbetsobjekt sekventiellt. I projektet kanske numret för varje arbetsobjekt inte matchar det du ser här.

Här flyttar du det femte objektet, Improve release cadence, till kolumnen Doing . Sedan tilldelar du dig själv till arbetsuppgiften. Förbättra versionstakt handlar om att välja ett distributionsmönster som gör att du snabbt kan släppa ändringar till dina användare.

Så här konfigurerar du arbetsobjektet:

  1. I Azure DevOps går du till Boardsoch väljer sedan Boards på menyn.

    Skärmbild av Azure DevOps som visar platsen för menyn Boards.

  2. Välj nedåtpilen längst ned på arbetsobjektet Förbättra versionstakt. Tilldela sedan arbetsobjektet till dig själv.

    Skärmbild av Azure Boards som visar platsen för nedåtpilen.

  3. Flytta arbetsobjektet från kolumnen Att göra till kolumnen Doing .

    Skärmbild av Azure Boards som visar kortet i kolumnen Pågående.

I slutet av den här modulen flyttar du kortet till kolumnen Klar när du har slutfört uppgiften.

Konfigurera projektet lokalt

Här läser du in projektet Space Game i Visual Studio Code, konfigurerar Git, klonar lagringsplatsen lokalt och konfigurerar den överordnade fjärrplatsen så att du kan ladda ned startkoden.

Anteckning

Om du redan har konfigurerat mslearn-tailspin-spacegame-web-deploy projektet lokalt kan du gå vidare till nästa avsnitt.

Öppna den integrerade terminalen

Visual Studio Code levereras med en integrerad terminal. Här redigerar du både filer och arbetar från kommandoraden.

  1. Starta Visual Studio Code.

  2. På menyn Visa väljer du Terminal.

  3. I listrutan väljer du Git Bash-. Om du är bekant med ett annat Unix-gränssnitt som du föredrar att använda väljer du gränssnittet i stället.

    En skärmbild av Visual Studio Code som visar platsen för Git Bash-gränssnittet.

    I terminalfönstret kan du välja valfritt skal som är installerat på ditt system. Du kan till exempel välja Git Bash, PowerShell eller ett annat gränssnitt.

    Här använder du Git Bash, en del av Git för Windows, vilket gör det enkelt att köra Git-kommandon.

    Not

    Om du inte ser Git Bash- visas som ett alternativ i Windows kontrollerar du att du har installerat Gitoch startar sedan om Visual Studio Code.

  4. Kör kommandot cd för att gå till katalogen där du vill arbeta. Välj din hemkatalog (~) eller en annan katalog om du vill.

    cd ~

Konfigurera Git

Om du är nybörjare på Git och GitHub kör du först några kommandon för att associera din identitet med Git och autentisera med GitHub. Mer information finns i Konfigurera Git.

Du måste minst utföra följande steg. Kör kommandona från den integrerade terminalen.

  1. Ange ditt användarnamn.
  2. Ange din inchecknings-e-postadress.
  3. Lagra ditt GitHub-lösenord.

Notera

Om du redan använder tvåfaktorautentisering med GitHub skapa en personlig åtkomsttoken. När du uppmanas att göra det använder du din token i stället för ditt lösenord.

Behandla din åtkomsttoken som ett lösenord. Förvara den på en säker plats.

Konfigurera projektet i Visual Studio Code

I lärvägen Bygga applikationer med Azure DevOps forkar du och klonar sedan ett Git-repository. Lagringsplatsen innehåller källkoden för webbplatsen Space Game. Din förgrening var ansluten till dina projekt i Azure DevOps så att bygget körs när du skickar ändringar till GitHub.

Viktig

I den här inlärningsvägen byter vi till ett annat Git-repositorium, mslearn-tailspin-spacegame-web-deploy. När du körde mallen för att konfigurera ditt Azure DevOps-projekt förgrenade processen lagringsplatsen automatiskt åt dig.

I den här delen klonar du din förgrening lokalt så att du kan ändra och bygga ut din pipelinekonfiguration.

Klona din fork lokalt

Nu har du en kopia av webbprojektet Space Game i ditt GitHub-konto. Nu ska du ladda ned, eller klona, en kopia till datorn så att du kan arbeta med den.

En klon, precis som en fork, är en kopia av ett arkiv. När du klonar en lagringsplats kan du göra ändringar, kontrollera att de fungerar som förväntat och sedan ladda upp ändringarna till GitHub. Du kan också synkronisera din lokala kopia med ändringar som andra autentiserade användare har gjort i GitHub-kopian av lagringsplatsen.

För att klona Space Game webbprojekt till din dator:

  1. Gå till din fork av webbprojektet Space Game (mslearn-tailspin-spacegame-web-deploy) på GitHub.

  2. Välj Code. Från fliken HTTPS väljer du sedan knappen bredvid den URL som visas för att kopiera URL:en till Urklipp.

    Skärmbild som visar hur du hittar URL:en och kopierar knappen från GitHub-lagringsplatsen.

  3. I Visual Studio Code går du till terminalfönstret.

  4. Gå till den katalog där du vill arbeta i terminalen. Välj din hemkatalog (~) eller en annan katalog om du vill.

    cd ~

  5. Kör kommandot git clone. Ersätt url:en som visas här med innehållet i Urklipp:

    git clone https://github.com/your-name/mslearn-tailspin-spacegame-web-deploy.git

  6. Flytta till katalogen mslearn-tailspin-spacegame-web-deploy. Det här är rotkatalogen för lagringsplatsen.

    cd mslearn-tailspin-spacegame-web-deploy

Konfigurera den överordnade fjärranslutningen

En fjärransluten är en Git-lagringsplats där teammedlemmar samarbetar (till exempel en lagringsplats på GitHub). Här visar du en lista över dina fjärrplatser och lägger till en fjärranslutning som pekar på Microsofts kopia av lagringsplatsen så att du kan hämta den senaste exempelkoden.

  1. Kör det här git remote-kommandot för att visa en lista över dina fjärranslutningar:

    git remote -v

    Du ser att du både har åtkomst för att hämta (ladda ner) och överföra (ladda upp) till ditt arkiv:

    origin  https://github.com/username/mslearn-tailspin-spacegame-web-deploy.git (fetch)
origin  https://github.com/username/mslearn-tailspin-spacegame-web-deploy.git (push)

    Origin anger lagringsplatsen på GitHub. När du förgrenar kod från en annan lagringsplats namnges ofta den ursprungliga fjärrplatsen (den du förgrenade från) överordnade.

  2. Kör det här git remote add-kommandot för att skapa en fjärrdatabas med namnet upstream som pekar på Microsoft-lagringsplatsen.

    git remote add upstream https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-deploy.git

  3. Kör git remote igen för att se ändringarna:

    git remote -v

    Du ser att du fortfarande har både hämtningsåtkomst (nedladdning) och push-åtkomst (uppladdning) till lagringsplatsen. Nu har du också hämtat åtkomst till Microsoft-lagringsplatsen:

    origin  https://github.com/username/mslearn-tailspin-spacegame-web-deploy.git (fetch)
origin  https://github.com/username/mslearn-tailspin-spacegame-web-deploy.git (push)
upstream        https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-deploy.git (fetch)

Öppna projektet i utforskaren

I Visual Studio Code pekar terminalfönstret på rotkatalogen för webbprojektet Space Game. Om du vill visa dess struktur och arbeta med filer öppnar du projektet från utforskaren.

  1. Det enklaste sättet att öppna projektet är att öppna Visual Studio Code igen i den aktuella katalogen. Det gör du genom att köra följande kommando från den integrerade terminalen:

    code -r .

    Du ser katalogen och filträdet i utforskaren.

  2. Öppna den integrerade terminalen igen. Terminalen placerar dig i roten för ditt webbprojekt.

Om code kommandot misslyckas måste du lägga till Visual Studio Code i systemets SÖKVÄG. Så här gör du:

  1. I Visual Studio Code väljer du F1 eller väljer Visa>kommandopalett för att få åtkomst till kommandopaletten.
  2. I kommandopaletten anger du kommandot Shell: Installera kommandot "code" i PATH.
  3. Upprepa föregående procedur för att öppna projektet i utforskaren.

Nu är du konfigurerad för att arbeta med Space Game källkod och din Azure Pipelines-konfiguration från din lokala utvecklingsmiljö.

Skapa Azure App Service-miljöer

Här skapar du de miljöer som definierar pipelinefaserna. Du skapar en App Service-instans som motsvarar varje steg: Dev, Testoch Mellanlagring.

I tidigare moduler använde du Azure CLI för att skapa dina App Service-instanser. Här gör du samma sak.

Viktig

Du behöver en egen Azure-prenumeration för att slutföra övningarna i den här modulen.

Ta upp Cloud Shell via Azure-portalen

  1. Gå till Azure-portalen och logga in.
  2. På menyn väljer du Cloud Shell-. När du uppmanas till det väljer du Bash--upplevelsen.

Välj en Azure-region

Här anger du standard region, eller geografisk plats, där dina Azure-resurser kommer att skapas.

  1. I Cloud Shell kör du följande az account list-locations kommando för att visa en lista över de regioner som är tillgängliga från din Azure-prenumeration.

    az account list-locations \
  --query "[].{Name: name, DisplayName: displayName}" \
  --output table

  2. I kolumnen Namn av resultatet väljer du en region som är nära dig. Välj till exempel eastasia eller westus2.

  3. Kör az configure för att ange din standardregion. Ersätt <REGION> med namnet på den region som du har valt.

    az configure --defaults location=<REGION>

    I det här exemplet anges westus2 som standardregion:

    az configure --defaults location=westus2

Skapa App Service-instanserna

Här skapar du App Service-instanser för de tre faser som du distribuerar till: Dev, Testoch Mellanlagring. Du lägger till en distributionsplats till Staging senare i den här modulen.

Anteckning

I utbildningssyfte använder du här standardinställningarna för nätverket. De här inställningarna gör din webbplats tillgänglig från Internet. I praktiken kan du konfigurera ett virtuellt Azure-nätverk som placerar din webbplats i ett nätverk som inte kan dirigeras från Internet, men som bara ditt team kan komma åt. När du är klar senare kan du konfigurera om nätverket så att webbplatsen blir tillgänglig för användarna.

  1. Generera ett slumptal i Cloud Shell som gör webbappens domännamn unikt:

    webappsuffix=$RANDOM

  2. Kör följande az group create kommando för att skapa en resursgrupp med namnet tailspin-space-game-rg.

    az group create --name tailspin-space-game-rg

  3. Kör följande kommandon för att skapa två App Service-planer.

    az appservice plan create \
  --name tailspin-space-game-test-asp \
  --resource-group tailspin-space-game-rg \
  --sku B1 \
  --is-linux

az appservice plan create \
  --name tailspin-space-game-prod-asp \
  --resource-group tailspin-space-game-rg \
  --sku P1V2 \
  --is-linux

    Viktig

    Om B1 SKU inte är tillgänglig som en del av din Azure-prenumeration du välja en annan plan, till exempel S1 (Standard).

    Kom ihåg att en App Service-plan definierar de processor-, minnes- och lagringsresurser som tillhandahålls för att webbappen ska kunna köras.

    Det första kommandot anger planen B1. Den här planen körs på nivån Basic. App Service-miljöerna använder den här planen för faserna Dev och Test. Planen B1 Basic är avsedd för appar med låga trafikkrav, till exempel i en utvecklings- eller testmiljö.

    Det andra kommandot anger planen P1V2, som körs på Premium-nivå. Den här planen används för Staging. Premium P1V2-planen är för produktionstillämpningar. Den körs på dedikerade virtuella datorinstanser.

    Plannivån Basic erbjuder inga ytterligare distributionsplatser. Det gör Premium-planen dock. Därför behöver du Premium plan för din mellanlagring miljö.

  4. Kör följande az webapp create-kommandon för att skapa de tre App Service-instanserna, en för var och en av Dev, Testoch Mellanlagring miljöer.

    az webapp create \
  --name tailspin-space-game-web-dev-$webappsuffix \
  --resource-group tailspin-space-game-rg \
  --plan tailspin-space-game-test-asp \
  --runtime "DOTNET|6.0"

az webapp create \
  --name tailspin-space-game-web-test-$webappsuffix \
  --resource-group tailspin-space-game-rg \
  --plan tailspin-space-game-test-asp \
  --runtime "DOTNET|6.0"

az webapp create \
  --name tailspin-space-game-web-staging-$webappsuffix \
  --resource-group tailspin-space-game-rg \
  --plan tailspin-space-game-prod-asp \
  --runtime "DOTNET|6.0"

    Observera att du här tillämpar samma App Service-plan, B1 Basic, på App Service-instanserna för Dev och Test. Du tillämpar App Service-planen Premium P1V2 på App Service-instansen för Staging-miljö.

  5. Kör följande az webapp list kommando för att visa värdnamnet och tillståndet för varje App Service-instans.

    az webapp list \
  --resource-group tailspin-space-game-rg \
  --query "[].{hostName: defaultHostName, state: state}" \
  --output table

    Observera värdnamnet för varje tjänst som körs. Du behöver dessa värdnamn senare när du verifierar ditt arbete. Här är ett exempel på värdnamnen:

    HostName                                                 State
-------------------------------------------------------  -------
tailspin-space-game-web-dev-21017.azurewebsites.net      Running
tailspin-space-game-web-test-21017.azurewebsites.net     Running
tailspin-space-game-web-staging-21017.azurewebsites.net  Running

  6. Som ett valfritt steg går du till ett eller flera av namnen. Kontrollera att de körs och att standardstartsidan visas.

    Du ser den här sidan i varje miljö:

    Skärmbild av standardstartsidan i Azure App Service.

Viktig

Sidan Rensa din Azure DevOps-miljö i den här modulen innehåller viktiga rensningssteg. Genom att rensa upp ser du till att du inte debiteras för Azure-resurser när du har slutfört den här modulen. Se till att utföra rensningsstegen även om du inte slutför den här modulen.

Skapa pipelinevariabler i Azure Pipelines

I Skapa en pipeline för flera steg med hjälp av Azure Pipelineshar du lagt till en variabel för var och en av App Service-instanserna som motsvarar Dev, Testoch Mellanlagring faser i pipelinen. Här gör du samma sak.

Varje steg i pipelinekonfigurationen använder dessa variabler för att identifiera vilken App Service-instans som ska distribueras till.

Så här lägger du till variablerna:

  1. I Azure DevOps går du till ditt Space Game - web - Distribueringsmönster projekt.

  2. Under Pipelinesväljer du Library.

    Skärmbild av Azure Pipelines som visar menyalternativet Bibliotek.

  3. Välj + variabelgrupp.

  4. Under Egenskaperanger du Releaseför variabelgruppens namn.

  5. Under Variablerväljer du + Lägg till.

  6. Som namn på variabeln anger du WebAppNameDev. Som värde anger du namnet på App Service-instansen som motsvarar din Dev-miljö, till exempel tailspin-space-game-web-dev-1234.

  7. Upprepa steg 5 och 6 två gånger till för att skapa variabler för Test och mellanlagring miljöer, som du ser i den här tabellen:

    Variabelnamn Exempelvärde
    WebAppNameTest tailspin-space-game-web-test-1234
    WebAppNameStaging tailspin-space-game-web-staging-1234

    Se till att ersätta varje exempelvärde med App Service-instansen som motsvarar din miljö.

    Viktig

    Ange namnet på App Service-instansen, inte dess värdnamn. I det här exemplet anger du tailspin-space-game-web-dev-1234 och inte tailspin-space-game-web-dev-1234.azurewebsites.net.

  8. Längst upp på sidan väljer du Spara för att spara variabeln i pipelinen.

    Din variabelgrupp liknar den här:

    Skärmbild av Azure Pipelines som visar variabelgruppen. Gruppen innehåller tre variabler.

Skapa utvecklings-, test- och mellanlagringsmiljöerna

I tidigare moduler skapade du miljöerna för dev, testoch staging. Här upprepar du processen.

Om du vill skapa dev, testoch staging miljöer:

  1. I Azure Pipelines väljer du Miljöer.

    Skärmbild av Azure Pipelines som visar platsen för menyalternativet Miljöer.

  2. Så här skapar du dev-miljön:

    1. Välj Skapa miljö.
    2. Under Namnska du ange dev.
    3. Lämna de återstående fälten som standardvärden.
    4. Välj Skapa.

  3. Så här skapar du en test miljö:

    1. Gå tillbaka till sidan Miljöer .
    2. Välj Ny miljö.
    3. Under Namnanger du test.
    4. Välj Skapa.

  4. Så här skapar du staging miljö:

    1. Gå tillbaka till sidan Miljöer.
    2. Välj Ny miljö.
    3. Under Namn, skriv staging.
    4. Välj Skapa.

Skapa en tjänstanslutning

Här skapar du en tjänstanslutning som gör att Azure Pipelines kan komma åt din Azure-prenumeration. Azure Pipelines använder den här tjänstanslutningen för att distribuera webbplatsen till App Service. Du skapade en liknande tjänstanslutning i föregående modul.

Viktig

Kontrollera att du är inloggad på både Azure-portalen och Azure DevOps under samma Microsoft-konto.

  1. I Azure DevOps går du till ditt Space Game – web – Distributionsmönster projekt.

  2. I det nedre hörnet på sidan väljer du Projektinställningar.

  3. Under Pipelinesväljer du Tjänstanslutningar.

  4. Välj Ny tjänstanslutningoch välj sedan Azure Resource Manageroch välj sedan Nästa.

  5. Längst upp på sidan Tjänstens huvudnamn (automatiskt). Välj sedan Nästa.

  6. Fyll i följande fält:

    Fält Värde
    Omfångsnivå Prenumeration
    Abonnemang Din Azure-prenumeration
    Resursgrupp tailspin-space-game-rg
    Namn på tjänstanslutning Resource Manager – Tailspin – Rymdspel

    Under processen kan du uppmanas att logga in på ditt Microsoft-konto.

  7. Kontrollera att Bevilja åtkomstbehörighet till alla pipelines har valts.

  8. Välj Spara.

    Azure DevOps utför en testanslutning för att kontrollera att den kan ansluta till din Azure-prenumeration. Om Azure DevOps inte kan ansluta har du chansen att logga in en andra gång.

Hämta grenen från GitHub

Här hämtar du blue-green-grenen från GitHub. Sedan du checka ut, eller växla till, den grenen.

Den här grenen innehåller projektet Space Game som du arbetade med i föregående moduler och en Azure Pipelines-konfiguration till att börja med.

  1. Öppna den integrerade terminalen i Visual Studio Code.

  2. Kör följande git kommandon för att hämta en gren med namnet blue-green från Microsoft-lagringsplatsen och växla till den grenen.

    git fetch upstream blue-green
git checkout -B blue-green upstream/blue-green

    Med formatet för dessa kommandon kan du hämta startkod från Microsoft GitHub-lagringsplatsen, som kallas upstream. Snart skickar du den här grenen till din GitHub-lagringsplats, som kallas origin.

  3. Som ett valfritt steg öppnar du azure-pipelines.yml från Visual Studio Code. Bekanta dig med den inledande konfigurationen.

    Konfigurationen liknar de som du skapade i föregående moduler i den här utbildningsvägen. Den bygger bara programmets Version konfiguration. I korthet utelämnar den utlösare, manuella godkännanden och tester som du har konfigurerat i tidigare moduler.

    För utbildningsändamål främjar den här konfigurationen ändringar från en gren till Dev, Testoch Staging. Ett mer robust angreppssätt kan uppmuntra ändringar från endast en versionsgren eller main. Du använde den här robusta metoden i Skapa en pipeline för flera steg med hjälp av Azure Pipelines-modulen.

Kör pipelinen och besök den installerade webbplatsen

Här push-överför du den första konfigurationen till GitHub så att du är uppdaterad med teamet. Senare lägger du till ett fack i miljön Mellanlagring så att du kan implementera en blågrön distribution.

  1. Öppna den integrerade terminalen i Visual Studio Code.

  2. Kör följande git commit-kommando för att lägga till ett tomt inlägg i commithistoriken.

    git commit --allow-empty -m "Trigger the pipeline"

    Det här steget är i utbildningssyfte. Det är inte typiskt. Vi tillhandahåller startkod som du inte behöver ändra nu. Flaggan --allow-empty ser till att nästa steg skickar grenen till GitHub och utlöser Azure Pipelines att köras.

    Om du utelämnade det här steget skulle kommandot git push som du kör i nästa steg inte vidta någon åtgärd. Det skulle därför inte utlösa körningen av Azure Pipelines.

  3. Kör följande git push kommando för att ladda upp grenen till din GitHub-lagringsplats.

    git push origin blue-green

  4. På Azure Pipelines går du till bygget. Spåra sedan kompileringen medan den körs. När du uppmanas till det väljer du Tillåt för att ge distributionsbehörigheter till de olika faserna.

  5. När pipelinekörningen har slutförts går du till sammanfattningssidan för att se din pipelinestatus.

    Skärmbild av Azure Pipelines som visar de slutförda stegen.

  6. Gå till den URL som motsvarar varje steg. Webbappen ska distribueras till varje miljö.

    Skärmbild av en webbläsare som visar webbplatsen Space Game i Dev-miljön.