Esercizio: Configurare l'ambiente Azure DevOps

25 minuti

In questa sezione si configurerà l'organizzazione azure DevOps per procedere con il resto di questo modulo e si creerà un ambiente del servizio Azure Kubernetes per distribuire l'applicazione.

Per raggiungere questi obiettivi, è possibile:

Aggiungere un utente all'organizzazione di Azure DevOps.
Configurare il progetto Azure DevOps.
Gestire il flusso di lavoro con Azure Boards.
Creare risorse di Azure usando l'interfaccia della riga di comando di Azure.
Creare variabili della pipeline in Azure Pipelines.
Creare una connessione di servizio per autenticarsi con Azure.
Aggiorna il manifeste della distribuzione Kubernetes.

Aggiungere un utente all'organizzazione

Per completare questo modulo, è necessaria una sottoscrizione di Azure . È possibile iniziare gratuitamente a usare Azure.

Anche se non è necessario usare Azure DevOps, è necessaria una sottoscrizione di Azure per la distribuzione nelle risorse di Azure tramite Azure DevOps. Per semplificare il processo, usare lo stesso account Microsoft per accedere sia alla sottoscrizione di Azure che all'organizzazione Azure DevOps.

Se si accede ad Azure e Azure DevOps usando account Microsoft diversi, è comunque possibile continuare aggiungendo un utente all'organizzazione DevOps con l'account Microsoft associato alla sottoscrizione di Azure. Per altri dettagli, vedere Aggiungere utenti all'organizzazione o al progetto . Durante l'aggiunta dell'utente, selezionare il livello di accesso Basic .

Dopo aver aggiunto l'utente con livello di accesso Basic, disconnettersi da Azure DevOps e accedere di nuovo usando l'account Microsoft associato alla sottoscrizione di Azure.

Ottenere il progetto Azure DevOps

In questa sezione viene eseguito un modello per creare il progetto in Azure DevOps.

Eseguire il modello

Eseguire un modello che configura l'organizzazione Azure DevOps.

Importante

Azure DevOps Demo Generator non è più supportato, ma è comunque possibile usarlo per creare ambienti demo. Al momento non esiste alcuna sostituzione e le relative funzionalità o disponibilità potrebbero cambiare in futuro.

Ottenere ed eseguire il progetto ADOGenerator in Visual Studio o nell'IDE preferito.
Quando viene richiesto di immettere il numero di modello dall'elenco dei modelli, immettere 40 per Automatizzare le distribuzioni multi-contenitore nei servizi Azure Kubernetes con Azure Pipelines e quindi premere INVIO.
Scegliere il metodo di autenticazione. È possibile configurare e usare un token di accesso personale (PAT) o usare l'account di accesso del dispositivo.

Annotazioni

Se si configura un token di accesso personale, assicurarsi di autorizzare gli ambiti necessari. Per questo modulo è possibile usare l'accesso completo, ma in una situazione reale è necessario assicurarsi di concedere solo gli ambiti necessari.
Immettere il nome dell'organizzazione di Azure DevOps e quindi premere INVIO.
Se richiesto, immettere il pat di Azure DevOps, quindi premere INVIO.
Immettere un nome di progetto, ad esempio Space Game - Web - Kubernetes, quindi premere INVIO.
Dopo aver creato il progetto, passare all'organizzazione di Azure DevOps nel browser (in https://dev.azure.com/<your-organization-name>/) e selezionare il progetto.

Creare una copia tramite fork del repository

Se non l'hai già fatto, crea un fork del repository mslearn-tailspin-spacegame-web-kubernetes.

In GitHub passare al repository mslearn-tailspin-spacegame-web-kubernetes.
Selezionare Fork in alto a destra dello schermo.
Scegli il tuo account GitHub come proprietario, quindi seleziona Crea fork.

Importante

L'unità Pulire l'ambiente Azure DevOps in questo modulo include passaggi cruciali per la pulizia. È consigliabile eseguire questi passaggi per evitare l'esaurimento dei minuti di compilazione gratuiti. Anche se non si completa questo modulo, è importante seguire la procedura di pulizia.

Impostare la visibilità del progetto

Inizialmente, il fork del repository Space Game in GitHub è impostato su pubblico mentre il progetto creato dal modello Azure DevOps è impostato su privato. Un repository pubblico in GitHub può essere accessibile da chiunque, mentre un repository privato è accessibile solo all'utente e alle persone con cui si sceglie di condividerlo. Analogamente, in Azure DevOps, i progetti pubblici forniscono l'accesso in sola lettura agli utenti non autenticati, mentre i progetti privati richiedono l'accesso e l'autenticazione degli utenti per accedere ai servizi.

Al momento, non è necessario modificare alcuna di queste impostazioni ai fini di questo modulo. Tuttavia, per i progetti personali, è necessario determinare la visibilità e l'accesso che si desidera concedere ad altri utenti. Ad esempio, se il progetto è open source, è possibile rendere pubblici il repository GitHub e il progetto Azure DevOps. Se il progetto è proprietario, probabilmente si preferirà che il repository GitHub e il progetto DevOps di Azure siano privati.

Più avanti, è possibile trovare le risorse seguenti utili per determinare quale opzione è migliore per il progetto:

Passare l'elemento di lavoro allo stato In corso

In questo passaggio si assegna un elemento di lavoro a se stessi in Azure Boards e lo si sposta nello stato In corso . Negli scenari reali, l'utente e il team creerebbero elementi di lavoro all'inizio di ogni sprint o iterazione di lavoro.

L'assegnazione di elementi di lavoro fornisce un elenco di controllo da cui lavorare e offre agli altri membri del team visibilità sullo stato di avanzamento e sul lavoro rimanente. Consente inoltre di applicare limiti di lavoro in corso (WIP) per impedire al team di assumere un lavoro eccessivo contemporaneamente.

Passare a Boards in Azure DevOps e quindi selezionare Boards dal menu.
Assegnare a sé stessi l’elemento di lavoro Crea versione multi-contenitore del sito Web orchestrato con Kubernetes selezionando la freccia giù situata nella parte inferiore della scheda.
Trascinare e rilasciare l'elemento di lavoro dalla colonna To Do alla colonna In corso . L'attività verrà spostata nella colonna Fine alla fine di questo modulo dopo averlo completato.

Creare l'ambiente del servizio Azure Kubernetes

In questo passaggio si creano le risorse del servizio Azure Kubernetes necessarie per distribuire la nuova versione del contenitore del sito Web.

In questo modulo si usa l'interfaccia della riga di comando di Azure per creare le risorse necessarie per distribuire ed eseguire l'applicazione nel servizio Azure Kubernetes. È possibile accedere all'interfaccia della riga di comando di Azure da un terminale o tramite Visual Studio Code. In questo modulo, tuttavia, si accede all'interfaccia della riga di comando di Azure da Azure Cloud Shell. Cloud Shell è un'esperienza shell basata su browser ospitata nel cloud, preconfigurata con l'interfaccia della riga di comando di Azure da usare con la sottoscrizione di Azure.

Importante

Per completare gli esercizi in questo modulo, è necessaria la propria sottoscrizione di Azure.

Avviare Cloud Shell

Passare al portale di Azure e accedere.
Selezionare l'opzione Cloud Shell dal menu e quindi scegliere l'esperienza Bash quando richiesto.

Annotazioni

Cloud Shell richiede una risorsa di archiviazione di Azure per rendere persistenti i file creati in Cloud Shell. Alla prima apertura, Cloud Shell chiede di creare un gruppo di risorse, un account di archiviazione e una condivisione di File di Azure. Questa configurazione viene usata automaticamente per tutte le sessioni di Cloud Shell future.

Selezionare un'area di Azure

Un'area fa riferimento a uno o più data center di Azure che si trovano in un'area geografica. Aree come Stati Uniti orientali, Stati Uniti occidentali ed Europa settentrionale sono esempi di tali aree. Ogni risorsa di Azure, inclusa un'istanza del servizio app, è associata a un'area.

Per semplificare l'esecuzione dei comandi, iniziare impostando un'area predefinita. Dopo aver impostato un'area predefinita, i comandi successivi usano tale area per impostazione predefinita, a meno che non si specifichi in modo esplicito un'area diversa.

Da Cloud Shell eseguire il comando seguente per elencare le aree disponibili nella sottoscrizione di Azure:
```
az account list-locations \
  --query "[].{Name: name, DisplayName: displayName}" \
  --output table
```
Selezionare un'area geografica dalla colonna Nome nell'output geograficamente vicino all'utente. Ad esempio, è possibile scegliere eastasia o westus2.
Eseguire il comando seguente per impostare l'area predefinita. Sostituire REGION con il nome dell'area scelta in precedenza.
```
az configure --defaults location=<REGION>
```
In questo esempio viene impostata westus2 come area predefinita.
```
az configure --defaults location=westus2
```

Creare le variabili di Bash

L'uso delle variabili Bash può rendere il processo di installazione più pratico e meno soggetto a errori. Questo approccio consente di evitare errori di digitazione accidentali definendo stringhe di testo condivise come variabili che possono essere usate in tutto lo script.

Da Cloud Shell generare un numero casuale per semplificare la creazione di nomi univoci globali per determinati servizi nel passaggio successivo.
```
resourceSuffix=$RANDOM
```
Creare nomi univoci globali per il Registro Azure Container e l'istanza del servizio Azure Kubernetes. Si noti che questi comandi usano virgolette doppie, che indicano a Bash di interpolare le variabili usando la sintassi inline.
```
registryName="tailspinspacegame${resourceSuffix}"
aksName="tailspinspacegame-${resourceSuffix}"
```
Creare un'altra variabile Bash per archiviare il nome del gruppo di risorse.
```
rgName='tailspin-space-game-rg'
```
Trova l'ultima versione di AKS.
```
az aks get-versions
```
Prendere nota della versione più recente.

Creare risorse di Azure

Annotazioni

In questa esercitazione le impostazioni di rete predefinite vengono usate a scopo di apprendimento. Queste impostazioni consentono l'accesso al sito Web da Internet. Tuttavia, in pratica, è possibile scegliere di configurare una rete virtuale di Azure che inserisce il sito Web in una rete che non è instradabile tramite Internet ed è accessibile solo dall'utente e dal team. Successivamente, è possibile riconfigurare la rete per rendere disponibile il sito Web agli utenti.

Eseguire il comando seguente per creare un gruppo di risorse con il nome definito in precedenza:
```
az group create --name $rgName
```
Eseguire il az acr create comando per creare un Registro Azure Container con il nome definito in precedenza:
```
az acr create \
  --name $registryName \
  --resource-group $rgName \
  --sku Standard
```
Esegui il comando az aks create per creare un'istanza di AKS con il nome che hai definito in precedenza. Sostituire <latest-AKS-version> con la versione annotata in precedenza.
```
az aks create \
  --name $aksName \
  --resource-group $rgName \
  --enable-addons monitoring \
  --kubernetes-version <latest-AKS-version> \
  --generate-ssh-keys
```
Annotazioni

Il completamento della distribuzione di Azure Kubernetes Service potrebbe richiedere dai 10 ai 15 minuti.

Creare una variabile per archiviare l'ID dell'entità servizio configurata per l'istanza del servizio Azure Kubernetes:

clientId=$(az aks show \
  --resource-group $rgName \
  --name $aksName \
  --query "identityProfile.kubeletidentity.clientId" \
  --output tsv)

Creare una variabile per archiviare l'ID del Registro Azure Container:

acrId=$(az acr show \
  --name $registryName \
  --resource-group $rgName \
  --query "id" \
  --output tsv)

Esegui il comando az acr list per recuperare l'URL del server di login per l'istanza di Registro Container di Azure.
```
az acr list \
 --resource-group $rgName \
 --query "[].{loginServer: loginServer}" \
 --output table
```
Assicurati di prendere nota del server di login per il registro dei container. Queste informazioni sono necessarie in un secondo momento durante la configurazione della pipeline. Ecco un esempio:
```
LoginServer                      
--------------------------------
tailspinspacegame4692.azurecr.io
```
Esegui il comando az role assignment create per creare un'assegnazione di ruolo e autorizzare il cluster AKS a connettersi al Registro Azure Container.
```
az role assignment create \
  --assignee $clientId \
  --role AcrPull \
  --scope $acrId
```

Importante

Creare un gruppo di variabili

In questa sezione si aggiungerà una variabile alla pipeline per archiviare il nome del Registro Azure Container. Definire il nome dell'istanza di Azure Container Registry come variabile nella configurazione della pipeline è consigliato rispetto a inserirlo direttamente nel codice. Ciò rende la configurazione più riutilizzabile e, nel caso in cui il nome dell'istanza venga modificato, è possibile aggiornare facilmente la variabile e attivare la pipeline senza dover modificare la configurazione.

Accedere all'organizzazione di Azure DevOps e quindi passare al progetto.
Selezionare Pipeline, e quindi Libreria dal pannello di navigazione a sinistra.
Selezionare Gruppi di variabili e quindi + Gruppo di variabili per aggiungere un nuovo gruppo di variabili.
Nella sezione Proprietà immettere Release per il nome del gruppo di variabili.
Nella sezione Variabili selezionare Aggiungi.
Immettere RegistryName per il nome della variabile e per il valore immettere il server di accesso del Registro Azure Container, ad esempio tailspinspacegame4692.azurecr.io.
Nella parte superiore della pagina selezionare Salva per salvare la variabile della pipeline. Questo è un esempio dell'aspetto del gruppo di variabili

Creare connessioni al servizio

Il passaggio successivo consiste nel creare connessioni al servizio che consentono ad Azure Pipelines di accedere alle istanze di Registro Azure Container e del servizio Azure Kubernetes. Creando queste connessioni di servizio, Azure Pipelines può eseguire il push dei container e indicare al cluster AKS di eseguirne il pull per aggiornare il servizio distribuito.

Importante

Assicurarsi di aver eseguito l'accesso al portale di Azure e ad Azure DevOps con lo stesso account Microsoft.

Creare una connessione al servizio Registro Docker

Accedere all'organizzazione di Azure DevOps e quindi passare al progetto.
Selezionare Impostazioni progetto nell'angolo inferiore della pagina.
Selezionare Connessioni al servizio nella sezione Pipeline .
Selezionare Nuova connessione al servizio, quindi selezionare Registro Docker e quindi avanti.
Nella parte superiore della pagina selezionare Azure Container Registry e quindi selezionare Entità servizio per il tipo di autenticazione.

Immettere i valori seguenti per ogni impostazione:

Impostazione	Valore
Abbonamento	la propria sottoscrizione di Azure
Registro Azure Container	Selezionare quello creato in precedenza
Nome della connessione al servizio	Connessione al Registro Container

Assicurarsi che la casella di controllo Concedi l'autorizzazione di accesso a tutte le pipeline sia selezionata.
Al termine, selezionare Salva .

Creare una connessione al servizio ARM

Ora creerai una connessione del servizio Azure Resource Manager per autenticarti con il tuo cluster AKS. Si usa una connessione al servizio ARM anziché Kubernetes perché i token di lunga durata non vengono più creati per impostazione predefinita da Kubernetes 1.24. Per altre informazioni, vedere questo post di blog di DevOps: Linee guida per la connessione al servizio per i clienti del servizio Azure Kubernetes che usano le attività di Kubernetes.

Selezionare Nuova connessione al servizio, selezionare Azure Resource Manager e quindi avanti.
Selezionare Entità servizio (automatico) poi selezionare Avanti.
Selezionare Sottoscrizione per il livello di ambito.

Immettere i valori seguenti per ogni impostazione.

Impostazione	Valore
Abbonamento	la propria sottoscrizione di Azure
Gruppo di risorse	Selezionare quello creato in precedenza
Nome della connessione al servizio	Connessione al cluster Kubernetes

Assicurarsi che la casella di controllo Concedi l'autorizzazione di accesso a tutte le pipeline sia selezionata.
Al termine, selezionare Salva .

Creare un ambiente pipeline

Selezionare Pipeline e quindi Ambienti.
Selezionare Crea ambiente per creare un nuovo ambiente.
Nel campo Nome immettere Dev.
Selezionare Nessuno nella sezione Risorsa e quindi selezionare Crea per creare l'ambiente della pipeline.

Aggiornare il manifesto di distribuzione di Kubernetes

In questa sezione si aggiornerà il manifesto di Kubernetes deployment.yml in modo che punti al registro contenitori creato in precedenza.

Passare all'account GitHub e selezionare il repository copiato tramite fork per questo modulo: mslearn-tailspin-spacegame-web-kubernetes.
Aprire il file manifesti/deployment.yml in modalità di modifica.

Modificare i riferimenti all'immagine del contenitore per usare il server di accesso del Registro Azure Container. Il manifesto seguente usa tailspinspacegame2439.azurecr.io come esempio.

apiVersion : apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: web
          image: tailspinspacegame4692.azurecr.io/web
          ports:
          - containerPort: 80

apiVersion : apps/v1
kind: Deployment
metadata:
  name: leaderboard
spec:
  replicas: 1
  selector:
    matchLabels:
      app: leaderboard
  template:
    metadata:
      labels:
        app: leaderboard
    spec:
      containers:
        - name: leaderboard
          image: tailspinspacegame4692.azurecr.io/leaderboard
          ports:
          - containerPort: 80

Eseguire il commit delle modifiche nel ramo main.

Commenti e suggerimenti

Questa pagina è stata utile?