Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

Last reviewed 2022-11-29 UTC

Questo tutorial mostra come utilizzare Azure Pipelines, Google Kubernetes Engine (GKE) e Google Container Registry per creare una pipeline di integrazione continua/deployment continuo (CI/CD) per un'applicazione web ASP.NET MVC. Ai fini di questo tutorial, puoi scegliere tra due applicazioni di esempio:

Un'applicazione web ASP.NET Core che utilizza .NET 6.0 e viene eseguita su Linux
Un'applicazione web ASP.NET MVC che utilizza .NET Framework 4 e viene eseguita su Windows

La pipeline CI/CD utilizza due cluster GKE separati, uno per lo sviluppo e uno per la produzione, come mostrato nel seguente diagramma.

Diagramma concettuale della pipeline CI/CD che mostra come gli sviluppatori e gli utenti finali interagiscono con l'applicazione

All'inizio della pipeline, gli sviluppatori commitano le modifiche al codebase di esempio. Questa azione attiva la pipeline per creare una release ed eseguirne il deployment nel cluster di sviluppo. Un release manager può quindi promuovere la release in modo che venga implementata nel cluster di produzione.

Questo tutorial è rivolto a sviluppatori e ingegneri DevOps. Presuppone che tu abbia conoscenze di base di Microsoft .NET,<0xx0D> Azure Pipelines e GKE. Il tutorial richiede anche l'accesso amministrativo a un account Azure DevOps.

Obiettivi

Connetti Google Container Registry ad Azure Pipelines per la pubblicazione di immagini Docker.
Prepara un'app di esempio.NET per il deployment in GKE.
Esegui l'autenticazione in modo sicuro su GKE senza dover utilizzare l'autenticazione legacy.
Utilizza la gestione delle release di Azure Pipelines per orchestrare i deployment di GKE.

Fuori ambito

Questo tutorial non tratta la connessione di Azure Pipelines a un cluster GKE privato o la connessione a reti private autorizzate.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

GKE
Cloud Load Balancing
Cloud Storage (for Container Registry)

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Consulta la pagina dei prezzi di Azure DevOps per eventuali tariffe che potrebbero essere applicate all'utilizzo di Azure DevOps.

Prima di iniziare

In genere è consigliabile utilizzare progetti separati per i carichi di lavoro di sviluppo e produzione, in modo che i ruoli e le autorizzazioni Identity and Access Management (IAM) possano essere concessi singolarmente. Per semplicità, questo tutorial utilizza un singolo progetto per entrambi i cluster GKE, uno per lo sviluppo e uno per la produzione.

Nella console Google Cloud , nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud .
Ruoli richiesti per selezionare o creare un progetto
- Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per il quale ti è stato concesso un ruolo.
- Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.
Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

Vai al selettore di progetti

Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

Assicurati di avere un account Azure DevOps e di disporre dell'accesso amministrativo. Se non hai ancora un account Azure DevOps, puoi registrarti nella home page di Azure DevOps.

Creazione di un progetto Azure DevOps

Utilizzi Azure DevOps per gestire il codice sorgente, eseguire build e test e orchestrare il deployment su GKE. Per iniziare, crea un progetto nel tuo account Azure DevOps.

Vai alla home page di Azure DevOps (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME).
Fai clic su Nuovo progetto.
Inserisci un nome per il progetto, ad esempio CloudDemo.
Imposta Visibilità su Privato, quindi fai clic su Crea.
Dopo aver creato il progetto, fai clic su Repository nel menu a sinistra.
Fai clic su Importa per creare un fork del repository dotnet-docs-samples da GitHub, quindi imposta i seguenti valori:
- Tipo di repository: Git
- URL di clonazione: https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
Fai clic su Importa.

Al termine del processo di importazione, viene visualizzato il codice sorgente del repository dotnet-docs-samples.

Connessione di Azure Pipelines a Google Container Registry

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

Configura un account di servizio per la pubblicazione delle immagini

Crea un Google Cloud service account nel tuo progetto:

Apri la console Google Cloud .
Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell
Per risparmiare tempo durante la digitazione dell'ID progetto e delle opzioni della zona Compute Engine, imposta i valori di configurazione predefiniti eseguendo i seguenti comandi:
```
gcloud config set project PROJECT_ID
gcloud config set compute/zone us-central1-a
```
Sostituisci PROJECT_ID con l'ID progetto del tuo progetto.

Abilita l'API Container Registry nel progetto:

gcloud services enable containerregistry.googleapis.com

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"

Concedi il ruolo IAM Amministratore di Artifact Registry (roles/artifactregistry.admin) all'account di servizio per consentire ad Azure Pipelines di eseguire il push in 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/artifactregistry.admin

Genera una chiave del 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

Visualizza i contenuti del file della chiave del account di servizio:
```
echo $(<azure-pipelines-publisher-oneline.json)
```
Avrai bisogno della chiave del account di servizio in uno dei passaggi successivi.

Crea una connessione al servizio per Google Container Registry

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

Nel menu DevOps di Azure, seleziona Impostazioni progetto, quindi Pipeline > Connessioni di servizio.
Fai clic su Crea connessione di servizio.
Dall'elenco, seleziona Docker Registry e poi fai clic su Avanti.
Nella finestra di dialogo, inserisci i valori per i seguenti campi:
- Tipo di registry: Altri
- Docker Registry: https://gcr.io/PROJECT_ID, sostituisci PROJECT_ID con il nome del tuo progetto (ad esempio, https://gcr.io/azure-pipelines-test-project-12345).
- ID Docker: _json_key
- Password: incolla i contenuti di azure-pipelines-publisher-oneline.json.
- Nome della connessione di servizio: gcr-tutorial
Fai clic su Salva per creare la connessione.

Creazione continua

Ora puoi utilizzare Azure Pipelines per configurare l'integrazione continua. Per ogni commit di cui viene eseguito il push nel repository Git, Azure Pipelines compila il codice e inserisce gli artefatti di build in un container Docker. Il container viene quindi pubblicato in Container Registry.

Il repository contiene già il Dockerfile seguente:

.NET/Linux

#
# 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"]

.NET Framework/Windows

#
# 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 crea una nuova pipeline che utilizza la sintassi YAML:

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

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

Esegui il commit delle modifiche e inviale ad Azure Pipelines.
Visual Studio
1. Apri Team Explorer e fai clic sull'icona Home.
2. Fai clic su Modifiche.
3. Inserisci un messaggio di commit come Add pipeline definition.
4. Fai clic su Esegui commit di tutto e push.
Riga di comando
1. Organizza 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 in Azure DevOps:
  
  git push
Nel menu Azure DevOps, seleziona Pipeline e poi fai clic su Crea pipeline.
Seleziona Azure Repos Git.
Seleziona il repository.
Nella pagina Review your pipeline YAML (Esamina il file YAML della pipeline), fai clic su Run (Esegui).

Viene attivata una nuova build. Il completamento della build potrebbe richiedere circa 6 minuti.
Per verificare che l'immagine sia stata pubblicata in Container Registry, passa al tuo progetto nella console Google Cloud , seleziona Container Registry > Immagini e poi fai clic su clouddemo.

Vengono visualizzate una singola immagine e il relativo tag. Il tag corrisponde all'ID numerico della build eseguita in Azure Pipelines.

Deployment continuo

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

A differenza di altri sistemi di integrazione continua, Azure Pipelines distingue tra la compilazione e il deployment e fornisce un insieme specializzato di strumenti denominati Release Management per tutte le attività correlate al deployment.

Azure Pipelines Release Management si basa sui seguenti concetti:

Una release si riferisce a un insieme di artefatti che costituiscono una versione specifica dell'app e che di solito sono il risultato di un processo di build.
Il deployment si riferisce al processo di acquisizione di una release e del suo deployment in un ambiente specifico.
Un deployment esegue un insieme di attività, che possono essere raggruppate in job.
Le fasi ti consentono di segmentare la pipeline e possono essere utilizzate per orchestrare le implementazioni in più ambienti, ad esempio ambienti di sviluppo e test.

L'artefatto principale prodotto dal processo di compilazione di CloudDemo è l'immagine Docker. Tuttavia, poiché l'immagine Docker viene pubblicata in Container Registry, non rientra nell'ambito di Azure Pipelines. Pertanto, l'immagine non è adatta a definire una release.

Per eseguire il deployment su Kubernetes, è necessario anche un manifest, che assomiglia a un elenco dei materiali. Il manifest non solo definisce le risorse che Kubernetes deve creare e gestire, ma specifica anche la versione esatta dell'immagine Docker da utilizzare. Il manifest Kubernetes è ideale per fungere da artefatto che definisce la release 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.
Un Ingress che espone l'applicazione a internet pubblico utilizzando un bilanciatore del carico HTTP(S) Cloud.

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

.NET/Linux

#
# 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

.NET Framework/Windows

#
# 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

Configura gli ambienti di sviluppo e di produzione

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

Crea cluster GKE

Torna all'istanza di Cloud Shell.

Abilita l'API GKE per il tuo progetto:

gcloud services enable container.googleapis.com

Crea il cluster di sviluppo utilizzando il seguente comando. Tieni presente che il completamento dell'operazione 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

Crea il cluster di produzione utilizzando il seguente comando. Nota che il completamento dell'operazione 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 eseguire l'autenticazione in Container Registry utilizzando un service accountGoogle Cloud , ma l'utilizzo di service account Google Cloud non è supportato da Azure Pipelines per l'autenticazione con GKE. Devi invece utilizzare un service account Kubernetes.

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

In Cloud Shell, connettiti al cluster di sviluppo:

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

Crea un account di servizio Kubernetes per Azure Pipelines:
```
kubectl create serviceaccount azure-pipelines-deploy
```

Crea un secret Kubernetes contenente una credenziale 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 -

Assegna il ruolo cluster-admin al account di servizio creando un'associazione di ruoli cluster:

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

Determina l'indirizzo IP del cluster:

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

Ti servirà tra poco.

Nel menu Azure DevOps, seleziona Impostazioni progetto e poi Pipeline > Connessioni di servizio.
Fai clic su Nuova connessione di servizio.
Seleziona Kubernetes e fai clic su Avanti.
Configura le seguenti impostazioni.

Nota :per ottenere alcuni di questi valori, devi eseguire i comandi kubectl in Cloud Shell e poi copiare i valori nella pagina Azure.
- Metodo di autenticazione: Service account.
- URL server: https://PRIMARY_IP. Sostituisci PRIMARY_IP con l'indirizzo IP che hai determinato in precedenza.
- Secret: il secret di Kubernetes che hai creato in precedenza. Per ottenere il segreto, esegui il comando seguente, copia il segreto e poi copialo nella pagina Azure.
```
kubectl get secret azure-pipelines-deploy-token -o yaml
```
- Nome della connessione di servizio: azure-pipelines-cicd-dev.
Fai clic su Salva.

Connetti Azure Pipelines al cluster di produzione

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

In Cloud Shell, connettiti al cluster di produzione:

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

Crea un account di servizio Kubernetes per Azure Pipelines:
```
kubectl create serviceaccount azure-pipelines-deploy
```

Assegna il ruolo cluster-admin al account di servizio creando un'associazione di ruoli cluster:

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

Determina l'indirizzo IP del cluster:

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

Ti servirà tra poco.

Nel menu Azure DevOps, seleziona Impostazioni progetto e poi Pipeline > Connessioni di servizio.
Fai clic su Nuova connessione di servizio.
Seleziona Kubernetes e fai clic su Avanti.
Configura le seguenti impostazioni:

Nota :per ottenere alcuni di questi valori, devi eseguire i comandi kubectl in Cloud Shell e poi copiare i valori nella pagina Azure.
- Metodo di autenticazione: Service account.
- URL server: https://PRIMARY_IP. Sostituisci PRIMARY_IP con l'indirizzo IP che hai determinato 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 della connessione di servizio: azure-pipelines-cicd-prod.
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.
Richiedere l'approvazione manuale prima di avviare un deployment nell'ambiente di produzione.
Deployment nell'ambiente di produzione.

Crea una definizione di release

Come primo passaggio, crea una nuova definizione di release.

Nel menu Azure DevOps, seleziona Pipeline > Release.
Fai clic su Nuova pipeline.
Dall'elenco dei modelli, seleziona Lavoro vuoto.
Quando ti viene chiesto un nome per lo stage, inserisci Development.
Nella parte superiore dello schermo, assegna il nome CloudDemo-KubernetesEngine alla release.
Nel diagramma della pipeline, fai clic su Aggiungi accanto ad Artefatti.
Seleziona Build e aggiungi le seguenti impostazioni:
- Tipo di origine: Build
- Origine (pipeline di build): seleziona la definizione di build (dovrebbe essere presente una sola opzione)
- Versione predefinita: Latest
- Alias origine: manifest
Fai clic su Aggiungi.
Nella casella Artefatto, fai clic su Trigger di deployment continuo (l'icona del fulmine) per aggiungere un trigger di deployment.
In Trigger di deployment continuo, imposta l'opzione su Attivato.
Fai clic su Salva.
Se vuoi, inserisci un commento, quindi conferma facendo clic su Ok.

La pipeline viene visualizzata in modo simile al seguente.

Esegui il deployment nel cluster di sviluppo

Ora che hai creato la definizione della release, puoi configurare il deployment nel cluster di sviluppo GKE.

Nel menu, passa alla scheda Attività.
Fai clic su Agent job e configura le seguenti impostazioni:
- Pool di agenti: Azure Pipelines
- Specifiche dell'agente: ubuntu-18.04
Accanto a Lavoro dell'agente, fai clic su Aggiungi un'attività al lavoro dell'agente per aggiungere un passaggio alla fase.
Seleziona l'attività Esegui il deployment su Kubernetes e fai clic su Aggiungi.
Fai clic sull'attività appena aggiunta e configura le seguenti impostazioni:
- Nome visualizzato: Deploy
- Azione: deploy
- Connessione al servizio Kubernetes: azure-pipelines-cicd-dev
- Namespace: default
- Strategia: Nessuna
- Manifest: manifest/drop/deployment.yaml
Fai clic su Salva.
Se vuoi, inserisci un commento, quindi conferma facendo clic su Ok.

Esegui il deployment nel cluster di produzione

Infine, configuri il deployment nel cluster di produzione GKE.

Nel menu, passa alla scheda Pipeline.
Nella casella Fasi, seleziona Aggiungi > Nuova fase.
Dall'elenco dei modelli, seleziona Lavoro vuoto.
Quando ti viene chiesto un nome per lo stage, inserisci Production.
Fai clic sull'icona a forma di fulmine della fase appena creata.
Configura le seguenti impostazioni:
- Seleziona trigger: Dopo la fase
- Fasi: Sviluppo
- Approvazioni pre-deployment: (attivate)
- Approvatori: seleziona il tuo nome utente.
La pipeline ora ha questo aspetto:
Passa alla scheda Tasks.
Passa il mouse sopra la scheda Attività e seleziona Attività > Produzione.
Fai clic su Agent job e configura le seguenti impostazioni:
- Pool di agenti: Azure Pipelines
- Specifiche dell'agente: ubuntu-18.04
Fai clic su Aggiungi un'attività al lavoro dell'agente per aggiungere un passaggio alla fase.
Seleziona l'attività Esegui il deployment su Kubernetes e fai clic su Aggiungi.
Fai clic sull'attività appena aggiunta e configura le seguenti impostazioni:
- Nome visualizzato: Deploy
- Azione: deploy
- Connessione al servizio Kubernetes: azure-pipelines-cicd-prod
- Namespace: default
- Strategia: Nessuna
- Manifest: manifest/drop/deployment.yaml
Fai clic su Salva.
Se vuoi, inserisci un commento, quindi conferma facendo clic su Ok.

esegui la pipeline.

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

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\
Alla riga 26, modifica il valore di ViewBag.Title da Home Page a This app runs on GKE.
Esegui il commit delle modifiche e poi inviale ad Azure Pipelines.
Visual Studio
1. Apri Team Explorer e fai clic sull'icona Home.
2. Fai clic su Modifiche.
3. Inserisci un messaggio di commit come Change site title.
4. Fai clic su Esegui commit di tutto e push.
Riga di comando
1. Organizza 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 in Azure Pipelines:
  
  git push
Nel menu Azure DevOps, seleziona Pipeline. Viene attivata una build.
Al termine della build, seleziona Pipeline > Release. Viene avviata una procedura di rilascio.
Fai clic su Release-1 per aprire la pagina dei dettagli e attendi che lo stato della fase Sviluppo diventi Riuscito.
Nella console Google Cloud , seleziona Kubernetes Engine > Servizi e Ingress > Ingress.
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.
Apri il link nella colonna Frontend della stessa riga. All'inizio potresti visualizzare un errore perché il bilanciatore del carico richiede alcuni minuti per diventare disponibile. Quando è pronto, verifica che CloudDemo sia stato eseguito il deployment e che utilizzi il titolo personalizzato.
In Azure Pipelines, fai clic sul pulsante Approva che si trova nella fase Prod per promuovere il deployment nell'ambiente di produzione.

Se non vedi il pulsante, potresti dover prima approvare o rifiutare una release precedente.
Se vuoi, inserisci un commento, quindi conferma facendo clic su Approva.
Attendi che lo stato dell'ambiente Prod passi a Riuscito. Potresti dover aggiornare manualmente la pagina nel browser.
Nella console Google Cloud , aggiorna la pagina Servizi e Ingress.
Individua il servizio Ingress per il cluster azure-pipelines-cicd-prod e attendi che il suo stato diventi Ok. L'operazione potrebbe richiedere alcuni minuti.
Apri il link nella colonna Frontend della stessa riga. Anche in questo caso, all'inizio potresti visualizzare un errore perché il bilanciatore del carico impiega alcuni minuti per diventare disponibile. Quando è pronta, vedrai di nuovo l'app CloudDemo con il titolo personalizzato, questa volta in esecuzione nel cluster di produzione.

Esegui la pulizia

Per evitare di incorrere in ulteriori costi dopo aver completato questo tutorial, elimina le entità che hai creato.

Elimina il progetto Azure Pipelines

Per eliminare il progetto Azure Pipelines, consulta la documentazione di Azure DevOps Services. L'eliminazione del progetto Azure Pipelines comporta la perdita di tutte le modifiche al codice sorgente.

Elimina lo Google Cloud sviluppo e i progetti

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud , vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona quello che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Configura il controllo dell'controllo dell'accesso granulare per Artifact Registry.
Scopri come eseguire il deployment di un gruppo SQL Server a disponibilità elevata su Compute Engine.
Scopri di più su .NET sulla piattaforma Google Cloud .
Esplora architetture, diagrammi e best practice di riferimento su Google Cloud. Consulta il nostro Cloud Architecture Center.

Creating a CI/CD pipeline with Azure Pipelines and Google Kubernetes Engine Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Fuori ambito

Costi

Prima di iniziare

Creazione di un progetto Azure DevOps

Connessione di Azure Pipelines a Google Container Registry

Configura un account di servizio per la pubblicazione delle immagini

Crea una connessione al servizio per Google Container Registry

Creazione continua

.NET/Linux

.NET Framework/Windows

.NET/Linux

.NET Framework/Windows

Visual Studio

Riga di comando

Deployment continuo

Configura il deployment Kubernetes

.NET/Linux

.NET Framework/Windows

Configura gli ambienti di sviluppo e di produzione

Crea cluster GKE

.NET/Linux

.NET Framework/Windows

.NET/Linux

.NET Framework/Windows

Connetti Azure Pipelines al cluster di sviluppo

Connetti Azure Pipelines al cluster di produzione

Configura la pipeline di rilascio

Crea una definizione di release

Esegui il deployment nel cluster di sviluppo

Esegui il deployment nel cluster di produzione

esegui la pipeline.

.NET/Linux

.NET Framework/Windows

Visual Studio

Riga di comando

Esegui la pulizia

Elimina il progetto Azure Pipelines

Elimina lo Google Cloud sviluppo e i progetti

Passaggi successivi

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