Creating a CI/CD pipeline with Azure Pipelines and Google Kubernetes Engine

Connessione di pipeline Azure a Google Container Registry

Prima di poter configurare l'integrazione continua per l'app CloudDemo, devi connettere Azure Pipelines a Container Registry. Questa connessione consente a Azure Pipelines di pubblicare immagini container in Container Registry.

Configura un account di servizio per pubblicare le immagini

Crea un account di servizio Google Cloud nel tuo progetto:

1. Apri la console Google Cloud.

2. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

3. Per risparmiare tempo durante la digitazione dell'ID progetto e delle opzioni della zona di Compute Engine, imposta i valori di configurazione predefiniti eseguendo questi comandi:

   gcloud config set project PROJECT_ID
   gcloud config set compute/zone us-central1-a
   

   Sostituisci PROJECT_ID con l'ID del tuo progetto.

4. Abilita l'API Container Registry nel progetto:

   gcloud services enable containerregistry.googleapis.com
   

5. Crea un account di servizio utilizzato da Azure Pipelines per pubblicare immagini Docker:

   gcloud iam service-accounts create azure-pipelines-publisher \
       --display-name="Azure Pipelines Publisher"
   

6. Concedi il ruolo IAM Amministratore archiviazione (roles/storage.admin) all'account di servizio per consentire il push delle pipeline Azure a Container Registry:

   AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com
   
   gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
       --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
       --role roles/storage.admin
   

7. Genera una chiave dell'account di servizio:

   gcloud iam service-accounts keys create azure-pipelines-publisher.json \
       --iam-account $AZURE_PIPELINES_PUBLISHER
   
   tr -d '\n' < azure-pipelines-publisher.json > azure-pipelines-publisher-oneline.json
   

8. Visualizza i contenuti del file della chiave dell'account di servizio:

   echo $(<azure-pipelines-publisher-oneline.json)
   

   Devi avere la chiave dell'account di servizio in uno dei seguenti passaggi.

Crea una connessione a un servizio per Google Container Registry

In Azure Pipelines, crea una nuova connessione di servizio per Container Registry:

1. Nel menu DevOps di Azure, seleziona Impostazioni progetto, quindi Pipelines > Connessioni del servizio.
2. Fai clic su Crea connessione servizio.
3. Seleziona Docker Registry dall'elenco, quindi fai clic su Next (Avanti).
4. Nella finestra di dialogo, inserisci i valori per i seguenti campi:
   • Tipo di registry: Altri
   • Docker Registry: https://gcr.io/PROJECT_ID, che sostituisce PROJECT_ID con il nome del tuo progetto (ad esempio https://gcr.io/azure-pipelines-test-project-12345).
   • ID dock: _json_key
   • Password: incolla i contenuti di azure-pipelines-publisher-oneline.json.
   • Nome connessione servizio: gcr-tutorial
5. Fai clic su Salva per creare la connessione.

Creazione continua

Ora puoi utilizzare le pipeline di Azure per configurare l'integrazione continua. Per ogni commit inviato al repository Git, Azure Pipelines crea il codice e pacchettizza gli artefatti di build in un container Docker. Il container viene quindi pubblicato in Container Registry.

Il repository contiene già il seguente Dockerfile:

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

FROM mcr.microsoft.com/dotnet/aspnet:6.0
EXPOSE 8080

#------------------------------------------------------------------------------
# Copy publishing artifacts.
#------------------------------------------------------------------------------

WORKDIR /app
COPY CloudDemo.MvcCore/bin/Release/net6.0/publish/ /app/

ENV ASPNETCORE_URLS=http://0.0.0.0:8080

#------------------------------------------------------------------------------
# Run application in Kestrel.
#------------------------------------------------------------------------------

ENTRYPOINT ["dotnet", "CloudDemo.MvcCore.dll"]

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

FROM mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019
EXPOSE 80
SHELL ["powershell", "-command"]

#------------------------------------------------------------------------------
# Add LogMonitor so that IIS and Windows logs are emitted to STDOUT and can be
# picked up by Docker/Kubernetes.
#
# See https://github.com/microsoft/windows-container-tools/wiki/Authoring-a-Config-File
# for details.
#------------------------------------------------------------------------------

ADD https://github.com/microsoft/windows-container-tools/releases/download/v1.1/LogMonitor.exe LogMonitor/
ADD LogMonitorConfig.json LogMonitor/

#------------------------------------------------------------------------------
# Copy publishing artifacts to webroot.
#------------------------------------------------------------------------------

ADD CloudDemo.Mvc/bin/Release/PublishOutput/ c:/inetpub/wwwroot/

#------------------------------------------------------------------------------
# Configure IIS using the helper functions from deployment.ps1.
#------------------------------------------------------------------------------

ADD deployment.ps1 /
RUN . /deployment.ps1; \
	Install-Iis; \
	Register-WebApplication -AppName "CloudDemo"; \
	Remove-Item /deployment.ps1

#------------------------------------------------------------------------------
# Run IIS, wrapped by LogMonitor.
#------------------------------------------------------------------------------

ENTRYPOINT ["C:\\LogMonitor\\LogMonitor.exe", "C:\\ServiceMonitor.exe", "w3svc"]

Ora creerai una nuova pipeline che utilizza la sintassi YAML:

1. Utilizzando Visual Studio o un client git a riga di comando, clona il nuovo repository Git e controlla il ramo main.
2. Nella directory principale del repository, crea un file denominato azure-pipelines.yml.

3. Copia il seguente codice nel file:

   .NET/Linux

   resources:
   - repo: self
     fetchDepth: 1
   pool:
     vmImage: ubuntu-20.04
   trigger:
   - main
   variables:
     TargetFramework: 'net6.0'
     BuildConfiguration: 'Release'
     DockerImageName: 'PROJECT_ID/clouddemo'
   steps:
   - task: DotNetCoreCLI@2
     displayName: Publish
     inputs:
       projects: 'applications/clouddemo/netcore/CloudDemo.MvcCore.sln'
       publishWebProjects: false
       command: publish
       arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
       zipAfterPublish: false
       modifyOutputPath: false
   - task: CmdLine@1
     displayName: 'Lock image version in deployment.yaml'
     inputs:
       filename: /bin/bash
       arguments: '-c "awk ''{gsub(\"CLOUDDEMO_IMAGE\", \"gcr.io/$(DockerImageName):$(Build.BuildId)\", $0); print}'' applications/clouddemo/netcore/deployment.yaml > $(build.artifactstagingdirectory)/deployment.yaml"'
   - task: PublishBuildArtifacts@1
     displayName: 'Publish Artifact'
     inputs:
       PathtoPublish: '$(build.artifactstagingdirectory)'
   - task: Docker@2
     displayName: 'Login to Container Registry'
     inputs:
       command: login
       containerRegistry: 'gcr-tutorial'
   - task: Docker@2
     displayName: 'Build and push image'
     inputs:
       Dockerfile: 'applications/clouddemo/netcore/Dockerfile'
       command: buildAndPush
       repository: '$(DockerImageName)'

   .NET Framework/Windows

   resources:
   - repo: self
     fetchDepth: 1
   pool:
     vmImage: windows-2019     # Matches WINDOWS_LTSC in GKE
     demands:
     - msbuild
     - visualstudio
   trigger:
   - master
   variables:
     Solution: 'applications/clouddemo/net4/CloudDemo.Mvc.sln'
     BuildPlatform: 'Any CPU'
     BuildConfiguration: 'Release'
     DockerImageName: 'PROJECT_ID/clouddemo'
   steps:
   - task: NuGetCommand@2
     displayName: 'NuGet restore'
     inputs:
       restoreSolution: '$(Solution)'
   - task: VSBuild@1
     displayName: 'Build solution'
     inputs:
       solution: '$(Solution)'
       msbuildArgs: '/p:DeployOnBuild=true /p:PublishProfile=FolderProfile'
       platform: '$(BuildPlatform)'
       configuration: '$(BuildConfiguration)'
   - task: PowerShell@2
     displayName: 'Lock image version in deployment.yaml'
     inputs:
       targetType: 'inline'
       script: '(Get-Content applications\clouddemo\net4\deployment.yaml) -replace "CLOUDDEMO_IMAGE","gcr.io/$(DockerImageName):$(Build.BuildId)" | Out-File -Encoding ASCII $(build.artifactstagingdirectory)\deployment.yaml'
   - task: PublishBuildArtifacts@1
     displayName: 'Publish Artifact'
     inputs:
       PathtoPublish: '$(build.artifactstagingdirectory)'
   - task: Docker@2
     displayName: 'Login to Container Registry'
     inputs:
       command: login
       containerRegistry: 'gcr-tutorial'
   - task: Docker@2
     displayName: 'Build and push image'
     inputs:
       Dockerfile: 'applications/clouddemo/net4/Dockerfile'
       command: buildAndPush
       repository: '$(DockerImageName)'

   Sostituisci PROJECT_ID con il nome del tuo progetto, quindi salva il file.

4. Esegui il commit delle modifiche e inviale a Azure Pipelines.

   Studio visivo

   1. Apri Team Explorer e fai clic sull'icona Home.
   2. Fai clic su Modifiche.
   3. Inserisci un messaggio di commit, ad esempio Add pipeline definition.
   4. Fai clic su Commit All and Push.

   Riga di comando

   1. Archiviazione temporanea di tutti i file modificati:

      git add -A
      

   2. Esegui il commit delle modifiche nel repository locale:

      git commit -m "Add pipeline definition"
      

   3. Esegui il push delle modifiche ad Azure DevOps:

      git push
      

5. Nel menu DevOps di Azure, seleziona Pipelines e fai clic su Crea pipeline.

6. Seleziona Azure Repos Git.

7. Seleziona il tuo repository.

8. Nella pagina Controlla la pipeline YAML, fai clic su Esegui.

   Viene attivata una nuova build. Il completamento della build potrebbe richiedere circa 6 minuti.

9. Per verificare che l'immagine sia stata pubblicata in Container Registry, passa al tuo progetto nella console Google Cloud, seleziona Container Registry > Immagini, quindi fai clic su clouddemo.

   Vengono visualizzate una singola immagine e il tag di questa immagine. Il tag corrisponde all'ID numerico della build che è stato eseguito in Azure Pipelines.

Deployment continuo

Con Azure Pipelines, che crea automaticamente il tuo codice e pubblica immagini Docker per ogni commit, ora puoi concentrarti sul deployment.

A differenza di altri sistemi di integrazione continua, Azure Pipelines distingue tra creazione e deployment e fornisce un set specializzato di strumenti etichettati per la gestione delle release per tutte le attività relative al deployment.

Azure Pipelines Release Management si basa sui seguenti concetti:

• Una release si riferisce a un insieme di elementi che costituiscono una versione specifica dell'app e che di solito sono il risultato di un processo di compilazione.
• Il deployment si riferisce al processo di prendere una release e di eseguirne il deployment in un ambiente specifico.
• Un deployment esegue un set di attività che possono essere raggruppate nei job.
• Le fasi ti consentono di segmentare la pipeline e possono essere utilizzate per orchestrare i deployment in più ambienti, ad esempio ambienti di sviluppo e test.

L'artefatto principale prodotto dal processo di compilazione CloudDemo è l'immagine Docker. Tuttavia, poiché l'immagine Docker è pubblicata in Container Registry, non rientra nell'ambito di Azure Pipelines. Pertanto, l'immagine non funge da definizione di release.

Per eseguire il deployment in Kubernetes, devi anche avere un manifest simile a una distinta base. Il manifest non solo definisce le risorse che Kubernetes prevede di creare e gestire, ma specifica anche la versione esatta dell'immagine Docker da utilizzare. Il manifest di Kubernetes è adatto a essere utilizzato come artefatto che definisce il rilascio in Azure Pipelines Release Management.

Configura il deployment Kubernetes

Per eseguire CloudDemo in Kubernetes, hai bisogno delle seguenti risorse:

• Un deployment che definisce un singolo pod che esegue l'immagine Docker prodotta dalla build.
• Un servizio NodePort che rende il pod accessibile a un bilanciatore del carico.
• Una risorsa Ingress che espone l'applicazione alla rete Internet pubblica utilizzando un bilanciatore del carico HTTP(S) Cloud.

Il repository contiene già il seguente manifest di Kubernetes che definisce queste risorse:

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

apiVersion: v1
kind: Service
metadata:
  name: clouddemo-netcore
spec:
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP
    name: http
  selector:
    app: clouddemo-netcore
  type: NodePort

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: clouddemo-netcore
spec:
  defaultBackend:
    service:
      name: clouddemo-netcore
      port:
        number: 80

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: clouddemo-netcore
spec:
  replicas: 2
  selector:
    matchLabels:
      app: clouddemo-netcore
  template:
    metadata:
      labels:
        app: clouddemo-netcore
    spec:
      containers:
      - name: clouddemo-netcore
        image: CLOUDDEMO_IMAGE
        ports:
          - containerPort: 8080
        livenessProbe:      # Used by deployment controller
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe:     # Used by Ingress/GCLB
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 3
          periodSeconds: 5
        resources:
          limits:
            memory: 1024Mi
          requests:
            memory: 256Mi

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

apiVersion: v1
kind: Service
metadata:
  name: clouddemo-net4
  annotations:
    cloud.google.com/neg: '{"ingress": false}' # Disable NEG

spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
    name: http
  selector:
    app: clouddemo-net4
  type: NodePort

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: clouddemo-net4
spec:
  defaultBackend:
    service:
      name: clouddemo-net4
      port:
        number: 80

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: clouddemo-net4
spec:
  replicas: 2
  selector:
    matchLabels:
      app: clouddemo-net4
  template:
    metadata:
      labels:
        app: clouddemo-net4
    spec:
      nodeSelector:
        kubernetes.io/os: windows
      containers:
      - name: clouddemo-net4
        image: CLOUDDEMO_IMAGE
        ports:
          - containerPort: 80
        livenessProbe:      # Used by deployment controller
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 120
          periodSeconds: 5
        readinessProbe:     # Used by Ingress/GCLB
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 10
          periodSeconds: 5
        resources:
          limits:
            memory: 1024Mi
          requests:
            memory: 256Mi

Configurare gli ambienti di sviluppo e produzione

Prima di tornare ad Azure Pipelines Release Management, devi creare i cluster GKE.

Crea cluster GKE

1. Torna alla tua istanza di Cloud Shell.

2. Abilita l'API GKE per il progetto:

   gcloud services enable container.googleapis.com

3. Crea il cluster di sviluppo utilizzando il comando seguente. Tieni presente che il completamento di questi passaggi potrebbe richiedere alcuni minuti:

   .NET/Linux

   gcloud container clusters create azure-pipelines-cicd-dev --enable-ip-alias
   

   .NET Framework/Windows

   gcloud container clusters create azure-pipelines-cicd-dev --enable-ip-alias
   
   gcloud container node-pools create azure-pipelines-cicd-dev-win \
       --cluster=azure-pipelines-cicd-dev \
       --image-type=WINDOWS_LTSC \
       --no-enable-autoupgrade \
       --machine-type=n1-standard-2
   

4. Crea il cluster di produzione utilizzando il comando seguente. Tieni presente che il completamento di questi passaggi potrebbe richiedere alcuni minuti:

   .NET/Linux

   gcloud container clusters create azure-pipelines-cicd-prod --enable-ip-alias
   

   .NET Framework/Windows

   gcloud container clusters create azure-pipelines-cicd-prod --enable-ip-alias
   
   gcloud container node-pools create azure-pipelines-cicd-prod-win \
       --cluster=azure-pipelines-cicd-prod \
       --image-type=WINDOWS_LTSC \
       --no-enable-autoupgrade \
       --machine-type=n1-standard-2
   

Connetti Azure Pipelines al cluster di sviluppo

Proprio come puoi utilizzare Azure Pipelines per connetterti a un registro Docker esterno come Container Registry, Azure Pipelines supporta l'integrazione di cluster Kubernetes esterni.

È possibile autenticarsi in Container Registry utilizzando un account di servizio Google Cloud, ma l'utilizzo degli account di servizio Google Cloud non è supportato da Azure Pipelines per l'autenticazione con GKE. Devi invece utilizzare un account di servizio Kubernetes.

Per connettere Azure Pipelines al tuo cluster di sviluppo, devi prima creare un account di servizio Kubernetes.

1. In Cloud Shell, connettiti al cluster di sviluppo:

   gcloud container clusters get-credentials azure-pipelines-cicd-dev

2. Crea un account di servizio Kubernetes per Azure Pipelines:

   kubectl create serviceaccount azure-pipelines-deploy

3. Crea un secret di Kubernetes contenente una credenziale del token per Azure Pipelines:

   kubectl create secret generic azure-pipelines-deploy-token --type=kubernetes.io/service-account-token --dry-run -o yaml \
     | kubectl annotate --local -o yaml -f - kubernetes.io/service-account.name=azure-pipelines-deploy \
     | kubectl apply -f -
   

4. Assegna il ruolo cluster-admin all'account di servizio creando un'associazione dei ruoli cluster:

   kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy

5. Determina l'indirizzo IP del cluster:

   gcloud container clusters describe azure-pipelines-cicd-dev --format=value\(endpoint\)
   

   Questo indirizzo sarà richiesto tra poco.

6. Nel menu DevOps di Azure, seleziona Impostazioni progetto, quindi seleziona Pipelines > Connessioni del servizio.

7. Fai clic su Nuova connessione al servizio.

8. Seleziona Kubernetes e fai clic su Avanti.

9. Configura le seguenti impostazioni.

   • Metodo di autenticazione: account di servizio.
   • URL server: https://PRIMARY_IP. Sostituisci PRIMARY_IP con l'indirizzo IP che hai stabilito in precedenza.
   • Secret: il secret di Kubernetes che hai creato in precedenza. Per ottenere il Secret, esegui il comando seguente, copia il Secret, quindi copia il Secret nella pagina Azure.

     kubectl get secret azure-pipelines-deploy-token -o yaml

   • Nome connessione servizio: azure-pipelines-cicd-dev.

10. Fai clic su Salva.

Connetti Azure Pipelines al cluster di produzione

Per connettere le pipeline di Azure al cluster di produzione, puoi seguire lo stesso approccio.

1. In Cloud Shell, connettiti al cluster di produzione:

   gcloud container clusters get-credentials azure-pipelines-cicd-prod

2. Crea un account di servizio Kubernetes per Azure Pipelines:

   kubectl create serviceaccount azure-pipelines-deploy

3. Assegna il ruolo cluster-admin all'account di servizio creando un'associazione dei ruoli cluster:

   kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy

4. Determina l'indirizzo IP del cluster:

   gcloud container clusters describe azure-pipelines-cicd-prod --format=value\(endpoint\)
   

   Questo indirizzo sarà richiesto tra poco.

5. Nel menu DevOps di Azure, seleziona Impostazioni progetto, quindi seleziona Pipelines > Connessioni del servizio.

6. Fai clic su Nuova connessione al servizio.

7. Seleziona Kubernetes e fai clic su Avanti.

8. Configura le seguenti impostazioni:

   • Metodo di autenticazione: account di servizio.
   • URL server: https://PRIMARY_IP. Sostituisci PRIMARY_IP con l'indirizzo IP che hai stabilito in precedenza.
   • Secret: esegui questo comando in Cloud Shell e copia l'output:

     kubectl get secret $(kubectl get serviceaccounts azure-pipelines-deploy -o custom-columns=":secrets[0].name") -o yaml

   • Nome connessione servizio: azure-pipelines-cicd-prod.

9. Fai clic su Salva.

Configura la pipeline di rilascio

Dopo aver configurato l'infrastruttura GKE, torni ad Azure Pipelines per automatizzare il deployment, che include quanto segue:

• Deployment nell'ambiente di sviluppo in corso...
• Richiedere l'approvazione manuale prima di avviare un deployment nell'ambiente di produzione.
• Deployment nell'ambiente di produzione in corso...

Crea una definizione di release

Come primo passaggio, crea una nuova definizione di release.

1. Nel menu DevOps di Azure, seleziona Pipelines > Releases.
2. Fai clic su Nuova pipeline.
3. Dall'elenco dei modelli, seleziona Job vuoto.
4. Quando ti viene chiesto un nome per la fase, inserisci Development.
5. Nella parte superiore dello schermo, assegna il nome CloudDemo-KubernetesEngine.
6. Nel diagramma della pipeline, accanto ad Artefatti, fai clic su Aggiungi.

7. Seleziona Build e aggiungi le seguenti impostazioni:

   • Tipo di origine: build
   • Origine (pipeline di build): seleziona la definizione di build (deve essere presente una sola opzione)
   • Versione predefinita: Latest
   • Alias origine: manifest

8. Fai clic su Add (Aggiungi).

9. Nella casella Elemento, fai clic su Trigger di deployment continuo (l'icona del fulmine) per aggiungere un trigger di deployment.

10. In Trigger di deployment continuo, imposta l'opzione su Abilitato.

11. Fai clic su Salva.

12. Se vuoi, inserisci un commento, quindi conferma facendo clic su OK.

    La pipeline viene visualizzata in modo simile al seguente.

    

Eseguire il deployment nel cluster di sviluppo

Con la definizione della release creata, puoi configurare il deployment nel cluster di sviluppo GKE.

1. Nel menu, passa alla scheda Attività.

2. Fai clic su Job agente e configura le seguenti impostazioni:

   • Pool di agenti: Azure Pipelines
   • Specifica dell'agente: ubuntu-18.04

3. Accanto a Job agente, fai clic su Aggiungi un'attività al job agente add per aggiungere un passaggio alla fase.

4. Seleziona l'attività Deploy to Kubernetes e fai clic su Add.

5. Fai clic sull'attività appena aggiunta e configura le seguenti impostazioni:

   • Nome visualizzato: Deploy
   • Azione: deploy
   • Connessione al servizio Kubernetes: azure-pipelines-cicd-dev
   • Spazio dei nomi: default
   • Strategia: Nessuna
   • Manifest: manifest/drop/deployment.yaml

6. Fai clic su Salva.

7. Se vuoi, inserisci un commento, quindi conferma facendo clic su OK.

Eseguire il deployment nel cluster di produzione

Infine, configurerai il deployment nel cluster di produzione GKE.

1. Nel menu, passa alla scheda Pipeline.
2. Nella casella Fasi, seleziona Aggiungi > Nuova fase.
3. Dall'elenco dei modelli, seleziona Job vuoto.
4. Quando ti viene chiesto un nome per la fase, inserisci Production.
5. Fai clic sull'icona a forma di lampo della fase appena creata.

6. Configura le seguenti impostazioni:

   • Seleziona trigger: dopo la fase.
   • Fasi: Dev
   • Approvazioni precedenti al deployment: (abilitate)
   • Approvatori: seleziona il tuo nome utente.

   La pipeline ora ha il seguente aspetto:

   

7. Passa alla scheda Attività.

8. Tieni il mouse sulla scheda Attività e seleziona Attività > Produzione.

9. Fai clic su Job agente e configura le seguenti impostazioni:

   • Pool di agenti: Azure Pipelines
   • Specifica dell'agente: ubuntu-18.04

10. Fai clic su Aggiungi un'attività al job agente add per aggiungere un passaggio alla fase.

11. Seleziona l'attività Deploy to Kubernetes e fai clic su Add.

12. Fai clic sull'attività appena aggiunta e configura le seguenti impostazioni:

    • Nome visualizzato: Deploy
    • Azione: deploy
    • Connessione al servizio Kubernetes: azure-pipelines-cicd-prod
    • Spazio dei nomi: default
    • Strategia: Nessuna
    • Manifest: manifest/drop/deployment.yaml

13. Fai clic su Salva.

14. Se vuoi, inserisci un commento, quindi conferma facendo clic su OK.

esegui la pipeline.

Ora che hai configurato l'intera pipeline, puoi testarla eseguendo una modifica del codice sorgente:

1. Sul computer locale, apri il file Index.cshtml dal repository Git che hai clonato in precedenza:

   .NET/Linux

   Il file si trova in applications\clouddemo\netcore\CloudDemo.MvcCore\Views\Home\

   .NET Framework/Windows

   Il file si trova in applications\clouddemo\net4\CloudDemo.Mvc\Views\Home\

2. Nella riga 26, modifica il valore di ViewBag.Title da Home Page a This app runs on GKE.

3. Esegui il commit delle modifiche e inviale ad Azure Pipelines.

   Studio visivo

   1. Apri Team Explorer e fai clic sull'icona Home.
   2. Fai clic su Modifiche.
   3. Inserisci un messaggio di commit, ad esempio Change site title.
   4. Fai clic su Commit All and Push.

   Riga di comando

   1. Archiviazione temporanea di tutti i file modificati:

      git add -A
      

   2. Esegui il commit delle modifiche nel repository locale:

      git commit -m "Change site title"
      

   3. Esegui il push delle modifiche ad Azure Pipelines:

      git push
      

4. Nel menu DevOps di Azure, seleziona Pipelines. Viene attivata una build.

5. Una volta terminata la build, seleziona Pipelines > Release. Viene avviato un processo di rilascio.

6. Fai clic su Release-1 per aprire la pagina dei dettagli e attendi lo stato della fase di Sviluppo per passare a Riuscito.

7. Nella console Google Cloud, seleziona Kubernetes Engine > Servizi e Ingress > In entrata.

8. Individua il servizio Ingress per il cluster azure-pipelines-cicd-dev e attendi che il suo stato passi a OK. L'operazione potrebbe richiedere alcuni minuti.

9. Apri il link nella colonna Frontend della stessa riga. Inizialmente potresti visualizzare un errore perché il bilanciatore del carico richiede alcuni minuti per diventare disponibile. Quando è pronto, osserva che è stato eseguito il deployment di CloudDemo e utilizza il titolo personalizzato.

10. In Pipelines di Azure, fai clic sul pulsante Approva nella fase di produzione per promuovere il deployment nell'ambiente di produzione.

    Se non vedi il pulsante, potrebbe essere necessario approvare o rifiutare una release precedente.

11. Se vuoi, inserisci un commento, quindi conferma facendo clic su Approva.

12. Attendi che lo stato dell'ambiente Prod passi a Riuscito. Potresti dover aggiornare manualmente la pagina nel browser.

13. Nella console Google Cloud, aggiorna la pagina Servizi e Ingress.

14. Individua il servizio Ingress per il cluster azure-pipelines-cicd-prod e attendi che il suo stato passi a OK. L'operazione potrebbe richiedere alcuni minuti.

15. Apri il link nella colonna Frontend della stessa riga. Anche in questo caso, inizialmente potresti visualizzare un messaggio di errore perché il bilanciatore del carico richiede alcuni minuti per diventare disponibile. Quando sarà pronta, vedrai di nuovo l'app CloudDemo con il titolo personalizzato, questa volta in esecuzione nel cluster di produzione.