Samouczek: tworzenie potoku wieloestowego za pomocą usługi Azure DevOps

Azure DevOps Services | Azure DevOps Server 2022 — Azure DevOps Server 2019

Możesz użyć potoku wieloetapowego usługi Azure DevOps, aby podzielić proces ciągłej integracji/ciągłego wdrażania na etapy reprezentujące różne części cyklu programowania. Użycie potoku wieloestegożowego zapewnia lepszy wgląd w proces wdrażania i ułatwia integrowanie zatwierdzeń i kontroli.

W tym artykule utworzysz dwa wystąpienia usługi App Service i utworzysz potok YAML z trzema etapami:

• Kompilacja: kompilowanie kodu źródłowego i tworzenie pakietu
• Tworzenie: wdrażanie pakietu w witrynie programistycznej na potrzeby testowania
• Przejściowe: wdrażanie w przejściowym wystąpieniu usługi aplikacja systemu Azure z ręcznym sprawdzaniem zatwierdzenia

W rzeczywistym scenariuszu może istnieć kolejny etap wdrażania w środowisku produkcyjnym w zależności od procesu DevOps.

Przykładowy kod w tym ćwiczeniu jest przeznaczony dla aplikacji internetowej platformy .NET dla gry w przestrzeni pretendentów, która zawiera ranking pokazujący wysokie wyniki. Wdrożysz zarówno w wystąpieniach programistycznych, jak i przejściowych aplikacji internetowej platformy Azure dla systemu Linux.

Wymagania wstępne

• Konto usługi GitHub, na którym można utworzyć repozytorium. Utwórz je bezpłatnie.
• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Organizacja i projekt usługi Azure DevOps. Utwórz je bezpłatnie.
• Możliwość uruchamiania potoków na agentach hostowanych przez firmę Microsoft. Możesz kupić zadanie równoległe lub zażądać warstwy Bezpłatna.

Rozwidlenie projektu

Rozwidlenie następującego przykładowego repozytorium w usłudze GitHub.

https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-deploy

Tworzenie wystąpień usługi App Service

Przed wdrożeniem potoku należy najpierw utworzyć wystąpienie usługi App Service do wdrożenia. Użyjesz interfejsu wiersza polecenia platformy Azure do utworzenia wystąpienia.

1. Zaloguj się w witrynie Azure Portal.

2. Z menu wybierz pozycję Cloud Shell i środowisko powłoki Bash .

3. Wygeneruj losową liczbę, która sprawia, że nazwa domeny aplikacji internetowej jest unikatowa. Zaletą unikatowej wartości jest to, że wystąpienie usługi App Service nie będzie miało konfliktu nazw z innymi osobami uczącymi się ukończenia tego samouczka.

   webappsuffix=$RANDOM    
   

4. Otwórz wiersz polecenia i użyj az group create polecenia , aby utworzyć grupę zasobów o nazwie tailspin-space-game-rg , która zawiera wszystkie wystąpienia usługi App Service. Zaktualizuj wartość tak location , aby korzystała z najbliższego regionu.

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

5. Użyj wiersza polecenia, aby utworzyć plan usługi App Service.

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

6. W wierszu polecenia utwórz dwa wystąpienia usługi App Service, po jednym dla każdego wystąpienia (deweloperskie i przejściowe) za az webapp create pomocą polecenia .

   az webapp create \
     --name tailspin-space-game-web-dev-$webappsuffix \
     --resource-group tailspin-space-game-rg \
     --plan tailspin-space-game-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-asp \
     --runtime "DOTNET|6.0"
   

7. W wierszu polecenia wyświetl listę obu wystąpień usługi App Service, aby sprawdzić, czy są uruchomione za az webapp list pomocą polecenia .

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

8. Skopiuj nazwy wystąpień usługi App Service do użycia jako zmienne w następnej sekcji.

Tworzenie projektu i zmiennych usługi Azure DevOps

Konfigurowanie projektu usługi Azure DevOps i potoku kompilacji. Dodasz również zmienne dla wystąpień programistycznych i przejściowych.

Potok kompilacji:

• Zawiera wyzwalacz uruchamiany po zmianie kodu na gałąź
• Definiuje dwie zmienne i buildConfigurationreleaseBranchName
• Zawiera etap o nazwie Kompilacja, który kompiluje aplikację internetową
• Publikuje artefakt, którego będziesz używać w późniejszym etapie

Dodawanie etapu kompilacji

1. Zaloguj się do organizacji usługi Azure DevOps i przejdź do projektu.

2. Przejdź do obszaru Potoki, a następnie wybierz pozycję Nowy potok lub Utwórz potok , jeśli tworzysz pierwszy potok.

3. Wykonaj kroki kreatora, wybierając najpierw usługę GitHub jako lokalizację kodu źródłowego.

4. Być może nastąpi przekierowanie do usługi GitHub w celu zalogowania się. Jeśli tak, wprowadź poświadczenia usługi GitHub.

5. Po wyświetleniu listy repozytoriów wybierz repozytorium.

6. Możesz zostać przekierowany do usługi GitHub, aby zainstalować aplikację Azure Pipelines. Jeśli tak, wybierz pozycję Zatwierdź i zainstaluj.

7. Po wyświetleniu karty Konfigurowanie wybierz pozycję Potok startowy.

8. Zastąp zawartość azure-pipelines.yml tym kodem.

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   stages:
   - stage: 'Build'
     displayName: 'Build the web application'
     jobs: 
     - job: 'Build'
       displayName: 'Build job'
       pool:
         vmImage: 'ubuntu-20.04'
         demands:
         - npm
   
       variables:
         wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
         dotnetSdkVersion: '6.x'
   
       steps:
       - task: UseDotNet@2
         displayName: 'Use .NET SDK $(dotnetSdkVersion)'
         inputs:
           version: '$(dotnetSdkVersion)'
   
       - task: Npm@1
         displayName: 'Run npm install'
         inputs:
           verbose: false
   
       - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
         displayName: 'Compile Sass assets'
   
       - task: gulp@1
         displayName: 'Run gulp tasks'
   
       - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
         displayName: 'Write build info'
         workingDirectory: $(wwwrootDir)
   
       - task: DotNetCoreCLI@2
         displayName: 'Restore project dependencies'
         inputs:
           command: 'restore'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Build the project - $(buildConfiguration)'
         inputs:
           command: 'build'
           arguments: '--no-restore --configuration $(buildConfiguration)'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Publish the project - $(buildConfiguration)'
         inputs:
           command: 'publish'
           projects: '**/*.csproj'
           publishWebProjects: false
           arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
           zipAfterPublish: true
   
       - publish: '$(Build.ArtifactStagingDirectory)'
         artifact: drop
   

9. Gdy wszystko będzie gotowe, wybierz pozycję Zapisz i uruchom.

Dodawanie zmiennych wystąpienia

1. W usłudze Azure DevOps przejdź do pozycji Biblioteka potoków>.

2. Wybierz pozycję + Grupa zmiennych.

3. W obszarze Właściwości dodaj wartość Release dla nazwy grupy zmiennych.

4. Utwórz dwie zmienne, aby odwoływać się do nazw hostów programistycznych i przejściowych. Zastąp wartość 1234 poprawną wartością wystąpienia.

   Nazwa zmiennej	Przykładowa wartość
   WebAppNameDev	tailspin-space-game-web-dev-1234
   WebAppNameStaging	tailspin-space-game-web-staging-1234

5. Wybierz pozycję Zapisz , aby zapisać zmienne.

Dodawanie etapu deweloperskiego

Następnie zaktualizujesz potok, aby podwyższyć poziom kompilacji do etapu deweloperskiego.

1. W usłudze Azure Pipelines przejdź do pozycji Potoki>.

2. Wybierz pozycję Edytuj w menu kontekstowym, aby edytować potok.

   

3. Zaktualizuj azure-pipelines.yml , aby uwzględnić etap deweloperski. Na etapie tworzenia potok będzie:

   • Uruchamianie po pomyślnym zakończeniu etapu kompilacji z powodu warunku

   • Pobieranie artefaktu z drop

   • Wdrażanie w usłudze aplikacja systemu Azure przy użyciu połączenia usługi Azure Resource Manager

     trigger:
     - '*'
     
     variables:
       buildConfiguration: 'Release'
       releaseBranchName: 'release'
     
     stages:
     - stage: 'Build'
       displayName: 'Build the web application'
       jobs: 
       - job: 'Build'
         displayName: 'Build job'
         pool:
           vmImage: 'ubuntu-20.04'
           demands:
           - npm
     
         variables:
           wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
           dotnetSdkVersion: '6.x'
     
         steps:
         - task: UseDotNet@2
           displayName: 'Use .NET SDK $(dotnetSdkVersion)'
           inputs:
             version: '$(dotnetSdkVersion)'
     
         - task: Npm@1
           displayName: 'Run npm install'
           inputs:
             verbose: false
     
         - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
           displayName: 'Compile Sass assets'
     
         - task: gulp@1
           displayName: 'Run gulp tasks'
     
         - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
           displayName: 'Write build info'
           workingDirectory: $(wwwrootDir)
     
         - task: DotNetCoreCLI@2
           displayName: 'Restore project dependencies'
           inputs:
             command: 'restore'
             projects: '**/*.csproj'
     
         - task: DotNetCoreCLI@2
           displayName: 'Build the project - $(buildConfiguration)'
           inputs:
             command: 'build'
             arguments: '--no-restore --configuration $(buildConfiguration)'
             projects: '**/*.csproj'
     
         - task: DotNetCoreCLI@2
           displayName: 'Publish the project - $(buildConfiguration)'
           inputs:
             command: 'publish'
             projects: '**/*.csproj'
             publishWebProjects: false
             arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
             zipAfterPublish: true
     
         - publish: '$(Build.ArtifactStagingDirectory)'
           artifact: drop
     
     - stage: 'Dev'
       displayName: 'Deploy to the dev environment'
       dependsOn: Build
       condition:  succeeded()
       jobs:
       - deployment: Deploy
         pool:
           vmImage: 'ubuntu-20.04'
         environment: dev
         variables:
         - group: Release
         strategy:
           runOnce:
             deploy:
               steps:
               - download: current
                 artifact: drop
               - task: AzureWebApp@1
                 displayName: 'Azure App Service Deploy: website'
                 inputs:
                   azureSubscription: 'your-subscription'
                   appType: 'webAppLinux'
                   appName: '$(WebAppNameDev)'
                   package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
     

4. Zmień zadanie, AzureWebApp@1 aby używało subskrypcji.

   1. Wybierz Ustawienia dla zadania.

      

   2. Zaktualizuj wartość subskrypcji platformy your-subscription Azure, aby używać własnej subskrypcji. W ramach tego procesu może być konieczne autoryzowanie dostępu. Jeśli wystąpi problem z autoryzowaniem zasobu w edytorze YAML, alternatywnym podejściem jest utworzenie połączenia z usługą.

      

   3. Ustaw wartość Typ aplikacji na Aplikację internetową w systemie Linux.

   4. Wybierz pozycję Dodaj , aby zaktualizować zadanie.

5. Zapisz i uruchom potok.

Dodawanie etapu przejściowego

Na koniec podwyższ poziom etapu deweloperskiego do etapu Przejściowego. W przeciwieństwie do środowiska deweloperskiego chcesz mieć większą kontrolę w środowisku przejściowym, które należy dodać do zatwierdzenia ręcznego.

Tworzenie środowiska przejściowego

1. W obszarze Azure Pipelines wybierz pozycję Środowiska.

2. Wybierz pozycję Nowe środowisko.

3. Utwórz nowe środowisko o nazwie przejściowej i ustawić zasób na Wartość Brak.

4. Na stronie środowiska przejściowego wybierz pozycję Zatwierdzenia i sprawdź.

   

5. Wybierz pozycję Zatwierdzenia.

6. W obszarze Osoby zatwierdzające wybierz pozycję Dodaj użytkowników i grupy, a następnie wybierz swoje konto.

7. W obszarze Instrukcje dotyczące osób zatwierdzających napisz zatwierdź tę zmianę, gdy będzie gotowa do przemieszczania.

8. Wybierz pozycję Zapisz.

Dodawanie nowego etapu do potoku

Do potoku zostanie dodany nowy etap Staging , który zawiera zatwierdzenie ręczne.

1. Edytuj plik potoku i dodaj sekcję Staging .

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   stages:
   - stage: 'Build'
     displayName: 'Build the web application'
     jobs: 
     - job: 'Build'
       displayName: 'Build job'
       pool:
         vmImage: 'ubuntu-20.04'
         demands:
         - npm
   
       variables:
         wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
         dotnetSdkVersion: '6.x'
   
       steps:
       - task: UseDotNet@2
         displayName: 'Use .NET SDK $(dotnetSdkVersion)'
         inputs:
           version: '$(dotnetSdkVersion)'
   
       - task: Npm@1
         displayName: 'Run npm install'
         inputs:
           verbose: false
   
       - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
         displayName: 'Compile Sass assets'
   
       - task: gulp@1
         displayName: 'Run gulp tasks'
   
       - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
         displayName: 'Write build info'
         workingDirectory: $(wwwrootDir)
   
       - task: DotNetCoreCLI@2
         displayName: 'Restore project dependencies'
         inputs:
           command: 'restore'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Build the project - $(buildConfiguration)'
         inputs:
           command: 'build'
           arguments: '--no-restore --configuration $(buildConfiguration)'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Publish the project - $(buildConfiguration)'
         inputs:
           command: 'publish'
           projects: '**/*.csproj'
           publishWebProjects: false
           arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
           zipAfterPublish: true
   
       - publish: '$(Build.ArtifactStagingDirectory)'
         artifact: drop
   
   - stage: 'Dev'
     displayName: 'Deploy to the dev environment'
     dependsOn: Build
     condition:  succeeded()
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: dev
       variables:
       - group: Release
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'your-subscription'
                 appType: 'webAppLinux'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Staging'
     displayName: 'Deploy to the staging environment'
     dependsOn: Dev
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: staging
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'your-subscription'
                 appType: 'webAppLinux'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   

2. Zmień zadanie na etapie przejściowym AzureWebApp@1 , aby używać subskrypcji.

   1. Wybierz Ustawienia dla zadania.

      

   2. Zaktualizuj wartość subskrypcji platformy your-subscription Azure, aby używać własnej subskrypcji. W ramach tego procesu może być konieczne autoryzowanie dostępu.

      

   3. Ustaw wartość Typ aplikacji na Aplikację internetową w systemie Linux.

   4. Wybierz pozycję Dodaj , aby zaktualizować zadanie.

3. Przejdź do uruchomienia potoku. Obejrzyj kompilację podczas jej uruchamiania. Gdy osiągnie Stagingwartość , potok czeka na ręczne zatwierdzenie wydania. Otrzymasz również wiadomość e-mail z informacją o oczekiwaniu na zatwierdzenie potoku.

   

4. Przejrzyj zatwierdzenie i zezwól na uruchomienie potoku.

   

Czyszczenie zasobów

Jeśli nie zamierzasz nadal korzystać z tej aplikacji, usuń grupę zasobów w witrynie Azure Portal i projekt w usłudze Azure DevOps, wykonując następujące czynności:

Aby wyczyścić grupę zasobów:

1. Przejdź do witryny Azure Portal i zaloguj się.

2. Na pasku menu wybierz pozycję Cloud Shell. Po wyświetleniu monitu wybierz środowisko powłoki Bash .

   

3. Uruchom następujące polecenie az group delete, aby usunąć użytą grupę zasobów . tailspin-space-game-rg

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

Aby usunąć projekt usługi Azure DevOps, w tym potok kompilacji:

1. W usłudze Azure DevOps przejdź do projektu.

2. Wybierz pozycję Ustawienia projektu.

3. W obszarze Szczegóły projektu wybierz pozycję Usuń.

Powiązana zawartość

• Kluczowe pojęcia dotyczące nowych użytkowników usługi Azure Pipelines
• Wdrażanie w usłudze App Service przy użyciu usługi Azure Pipelines