Esercizio: Configurare l'ambiente Azure DevOps

15 minuti

In questa sezione è necessario assicurarsi che l'organizzazione Azure DevOps sia configurata per completare il resto del modulo. È anche possibile creare gli ambienti del servizio app di Azure da distribuire in un secondo momento.

Per raggiungere questi obiettivi, è possibile:

Aggiungere un utente per assicurarsi che Azure DevOps possa connettersi alla sottoscrizione di Azure.
Configurare un progetto Azure DevOps per questo modulo.
In Azure Boards spostare l'elemento di lavoro per questo modulo nella colonna In corso.
Verificare che il progetto sia configurato in locale, in modo da poter eseguire il push delle modifiche nella pipeline.
Creare gli ambienti del servizio app di Azure usando l'interfaccia della riga di comando di Azure in Azure Cloud Shell.
Creare variabili di pipeline che definiscono i nomi degli ambienti di App Service.
Creare una connessione al servizio che consente ad Azure Pipelines di accedere in modo sicuro alla sottoscrizione di Azure.

Aggiungere un utente ad Azure DevOps

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

Non è necessaria una sottoscrizione di Azure per usare Azure DevOps, ma qui si usa Azure DevOps per distribuire le risorse di Azure esistenti nella sottoscrizione di Azure. Per semplificare il processo, usare lo stesso account Microsoft per accedere sia alla sottoscrizione di Azure che all'organizzazione Azure DevOps.

Se si usano account Microsoft diversi per accedere ad Azure e Azure DevOps, aggiungere un utente all'organizzazione DevOps con l'account Microsoft usato per accedere ad Azure. Per altre informazioni, vedere Aggiungere utenti all'organizzazione o al progetto. Quando si aggiunge l'utente, selezionare il livello di accesso Basic .

Esci da Azure DevOps e accedi di nuovo. Usare l'account Microsoft usato per accedere alla sottoscrizione di Azure.

Ottenere il progetto Azure DevOps

In questo caso, assicurarsi che l'organizzazione di Azure DevOps sia configurata per completare il resto di questo modulo. A tale scopo, si esegue un modello che crea un progetto in Azure DevOps.

I moduli di questo percorso di apprendimento sono da seguire in successione. Si seguirà il team Web di Tailspin nel viaggio alla scoperta di DevOps. Ai fini dell'apprendimento, ogni modulo ha un proprio progetto 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 30 per Creare una pipeline a più fasi con Azure Pipelines, 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 - Multistage, 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 lo hai già fatto, crea un fork del repository mslearn-tailspin-spacegame-web-deploy.

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

Importante

In questo modulo la pagina Pulisci l'ambiente Azure DevOps contiene importanti passaggi di pulizia. La pulizia consente di assicurarsi che i minuti di compilazione gratuiti non si esauriscano. Anche se non si completa questo modulo, assicurarsi di seguire i passaggi di pulizia.

Impostare la visibilità del progetto

Inizialmente, il fork del repository Space Game su GitHub è pubblico, mentre il progetto creato dal modello Azure DevOps è 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 è closed source, 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:

Usare progetti privati e pubblici
Modificare la visibilità del progetto in modalità pubblica o privata
Setting repository visibility (Impostazione della visibilità del repository)

Passare l'elemento di lavoro allo stato In corso

In questo caso si assegna un elemento di lavoro a se stessi in Azure Boards. È anche possibile spostare l'elemento di lavoro nello stato In corso . In pratica, l'utente e il team creeranno elementi di lavoro all'inizio di ogni sprint o iterazione di lavoro.

Questo compito ti fornisce un elenco di controllo su cui basarti per svolgere il lavoro. Offre agli altri membri del team visibilità su ciò che si sta lavorando e sulla quantità di lavoro lasciata. L'elemento di lavoro consente anche di applicare limiti di lavoro in corso (WIP) in modo che il team non assuma troppo lavoro contemporaneamente.

Tenere presente che il team ha stabilito questi tre problemi principali per lo sprint corrente.

Screenshot di Azure Boards che mostra le cinque attività per questo sprint.

Annotazioni

All'interno di un'organizzazione Azure DevOps gli elementi di lavoro sono numerati in modo sequenziale. Nel progetto il numero per ogni elemento di lavoro potrebbe non corrispondere a quello visualizzato qui.

Qui si sposta il primo elemento, Creare una pipeline a più fasi, nella colonna In corso . Assegnare quindi l'elemento di lavoro a sé stessi. Creare una pipeline a più fasi e significa definire ogni fase della distribuzione del sito web Space Game.

Per configurare l'elemento di lavoro:

Dall'interfaccia di Azure DevOps, vai su Boards. Quindi, dal menu selezionare Boards.
Nella scheda Crea una pipeline a più fasi selezionare la freccia giù. Assegnare quindi l'elemento di lavoro a se stessi.
Spostare l'elemento di lavoro dalla colonna Attività alla colonna In corso .

Al termine di questo modulo, la scheda verrà spostata nella colonna Fine dopo aver completato l'attività.

Configurare il progetto in locale

Qui si carica il progetto Space Game in Visual Studio Code, si configura Git, si clona il repository in locale e si imposta il repository remoto upstream in modo da poter scaricare il codice di avvio.

Annotazioni

Se si è già configurato con il progetto mslearn-tailspin-spacegame-web-deploy in locale, è possibile passare alla sezione successiva.

Aprire il terminale integrato

In Visual Studio Code è disponibile un terminale integrato. Qui è possibile modificare i file e lavorare dalla riga di comando.

Avvia Visual Studio Code.
Nel menu Visualizza selezionare Terminale.
Nell'elenco a discesa selezionare Git Bash. Se si ha familiarità con un'altra shell Unix che si preferisce usare, selezionare invece tale shell.

Nella finestra del terminale è possibile scegliere qualsiasi shell installata nel sistema. Ad esempio, è possibile scegliere Git Bash, PowerShell o un'altra shell.

Qui si userà Git Bash, parte di Git per Windows, che semplifica l'esecuzione di comandi Git.

Annotazioni

In Windows, se Git Bash non è elencato come opzione, assicurarsi di aver installato Git e quindi riavviare Visual Studio Code.
Eseguire il cd comando per passare alla directory in cui si vuole lavorare. Scegliere la home directory (~) o una directory diversa, se necessario.
```
cd ~
```

Configurazione di Git

Se non si ha familiarità con Git e GitHub, eseguire prima alcuni comandi per associare l'identità a Git ed eseguire l'autenticazione con GitHub. Per altre informazioni, vedere Configurare Git.

Come minimo, è necessario completare i passaggi seguenti. Eseguire i comandi dal terminale integrato.

Annotazioni

Se si usa già l'autenticazione a due fattori con GitHub, creare un token di accesso personale. Quando richiesto, usare il token al posto della password.

Considerare il token di accesso come una password. e conservarlo in un luogo sicuro.

Configurare il progetto in Visual Studio Code

Nel percorso di apprendimento Compilare applicazioni con Azure DevOps è stato creato un fork e quindi clonato un repository Git. Il repository contiene il codice sorgente del sito web Space Game. Il fork è stato connesso ai progetti in Azure DevOps in modo che la compilazione venga eseguita quando si esegue il push delle modifiche in GitHub.

Importante

In questo percorso di apprendimento si passa a un repository Git diverso, mslearn-tailspin-spacegame-web-deploy. Quando hai eseguito il modello per configurare il tuo progetto Azure DevOps, il processo ha creato automaticamente un fork del repository per te.

In questa parte si clona il fork in locale in modo da poter modificare e compilare la configurazione della pipeline.

Clonare il fork in locale

È ora disponibile una copia del progetto Web Space Game nell'account GitHub. A questo punto, è possibile scaricare o clonare una copia nel computer per poterla usare.

Un clone, analogamente a un fork, è una copia di un repository. Quando si clona un repository, è possibile apportare modifiche, verificare che funzionino come previsto e quindi caricare tali modifiche in GitHub. È anche possibile sincronizzare la copia locale con le modifiche apportate da altri utenti autenticati alla copia gitHub del repository.

Per clonare il progetto Web Space Game nel computer:

Vai al fork del progetto web Space Game (mslearn-tailspin-spacegame-web-deploy) su GitHub.
Seleziona Codice. Nella scheda HTTPS selezionare quindi il pulsante accanto all'URL visualizzato per copiare l'URL negli Appunti.
In Visual Studio Code passare alla finestra del terminale.
Nel terminale passare alla directory in cui si vuole lavorare. Scegliere la home directory (~) o una directory diversa, se necessario.
```
cd ~
```
Eseguire il comando git clone. Sostituire l'URL visualizzato in questa sezione con il contenuto degli Appunti:
```
git clone https://github.com/your-name/mslearn-tailspin-spacegame-web-deploy.git
```
Passare alla directory mslearn-tailspin-spacegame-web-deploy. Si tratta della directory radice del repository.
```
cd mslearn-tailspin-spacegame-web-deploy
```

Impostare il repository remoto upstream

Un repository Git remoto è un repository Git in cui i membri del team collaborano (ad esempio un repository in GitHub). Qui sono elencati i repository remoti ed è possibile aggiungerne uno che punta alla copia Microsoft del repository in modo che sia possibile ottenere il codice di esempio più recente.

Esegui questo comando git remote per elencare i remoti:
```
git remote -v
```
Puoi vedere che hai accesso sia al fetch (download) che al push (upload) sul tuo repository.
```
origin  https://github.com/username/mslearn-tailspin-spacegame-web-deploy.git (fetch)
origin  https://github.com/username/mslearn-tailspin-spacegame-web-deploy.git (push)
```
Origin specifica il repository in GitHub. Quando si crea un fork del codice da un altro repository, il repository remoto originale (quello da cui è stato eseguito il fork) viene spesso denominato upstream.
Esegui questo comando git remote add per creare un repository remoto denominato upstream che punta al repository di Microsoft:
```
git remote add upstream https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-deploy.git
```

Eseguire git remote di nuovo per visualizzare le modifiche:

git remote -v

Si vede che si dispone ancora sia dell'accesso per il recupero (download) sia dell'accesso per il caricamento (push) al proprio repository. È ora anche possibile recuperare l'accesso al repository Microsoft:

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

Aprire il progetto in Esplora file

In Visual Studio Code, la finestra del terminale punta alla directory principale del progetto web Space Game. Ora si aprirà il progetto da Esplora file per poterne visualizzare la struttura e usare i file.

Il modo più semplice per aprire il progetto è riaprire Visual Studio Code nella directory corrente. A questo scopo, eseguire il comando seguente nel terminale integrato:
```
code -r .
```
In Esplora file vengono visualizzati la directory e l'albero dei file.
Riaprire il terminale integrato. Il terminale posiziona l'utente alla radice del progetto Web.

Se il comando code non riesce, è necessario aggiungere Visual Studio Code al percorso di sistema. A questo scopo:

In Visual Studio Code, selezionare F1 o selezionare Visualizza>Palette comandi per accedere alla Palette comandi.
Nella palette dei comandi, inserisci Comando shell: Installa il comando 'code' in PATH.
Ripetere la procedura precedente per aprire il progetto in Esplora file.

È ora possibile usare il codice sorgente di Space Game e la configurazione di Azure Pipelines dall'ambiente di sviluppo locale.

Creare gli ambienti del servizio app di Azure

In questo caso si creano gli ambienti che definiscono le fasi della pipeline. Si crea un'istanza del servizio app per ogni fase: sviluppo, test e gestione temporanea.

In questo modulo si usa l'interfaccia della riga di comando di Azure per visualizzare tre istanze del servizio app. È possibile accedere all'interfaccia della riga di comando di Azure da un terminale o tramite Visual Studio Code. Qui si accede all'interfaccia della riga di comando di Azure da Azure Cloud Shell. Questa esperienza di shell basata sul browser è ospitata nel cloud. In Cloud Shell l'interfaccia della riga di comando di Azure è configurata per essere usata con la sottoscrizione di Azure.

Importante

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

Visualizzare Cloud Shell tramite il portale di Azure

Aprire il portale di Azure e accedere.
Dal menu selezionare Cloud Shell. Quando viene richiesto, selezionare l'esperienza Bash.

Annotazioni

Cloud Shell richiede una risorsa di archiviazione di Azure per rendere persistenti tutti i file creati in Cloud Shell. Quando si apre Per la prima volta Cloud Shell, viene richiesto di creare un gruppo di risorse, un account di archiviazione e una condivisione file di Azure. Questa configurazione viene usata automaticamente per tutte le sessioni di Cloud Shell future.

Selezionare un'area di Azure

Un'area è uno o più data center di Azure all'interno di una posizione geografica. Stati Uniti orientali, Stati Uniti occidentali ed Europa settentrionale sono esempi di aree. A ogni risorsa di Azure, inclusa un'istanza del servizio app, viene assegnata un'area.

Per semplificare l'esecuzione dei comandi, iniziare selezionando un'area predefinita. Dopo aver specificato l'area predefinita, i comandi successivi usano tale area a meno che non si specifichi un'area diversa.

Da Cloud Shell eseguire il comando seguente az account list-locations per elencare le aree disponibili dalla sottoscrizione di Azure.
```
az account list-locations \
  --query "[].{Name: name, DisplayName: displayName}" \
  --output table
```
Nella colonna Name dell'output, seleziona una regione vicina a te. Ad esempio, scegliere eastasia o westus2.
Eseguire az configure per impostare l'area predefinita. Sostituire <REGION> con il nome dell'area selezionata.
```
az configure --defaults location=<REGION>
```
Questo esempio imposta westus2 come area predefinita:
```
az configure --defaults location=westus2
```

Creare le istanze del servizio app

In questo caso si creano le istanze del servizio app per le tre fasi in cui vengono distribuite: Sviluppo, Test e Pre-produzione. Ecco una breve panoramica del processo che si segue:

Generare un numero casuale che renda univoco il nome di dominio dell'app Web.

Questo passaggio è destinato all'apprendimento. In pratica, scegliere un nome di dominio che corrisponda al nome dell'app o del servizio.
Creare un gruppo di risorse contenente tutte le istanze del servizio app.

Ai fini dell'apprendimento, qui si crea un gruppo di risorse che contiene tutte le istanze del servizio app. In pratica, è possibile creare un gruppo di risorse separato per ogni istanza del servizio app in modo da poter controllare meglio il ciclo di vita di ogni istanza.
Creare un piano di servizio app.

Un piano di servizio app definisce le risorse di CPU, memoria e archiviazione per l'app Web. In questa unità si usa il piano B1 Basic. Questo piano è destinato alle app con requisiti di traffico ridotti. I piani Standard e Premium sono destinati ai carichi di lavoro di produzione. Questi piani vengono eseguiti in istanze di macchina virtuale dedicate.
Per ognuno degli ambienti di sviluppo, test e gestione temporanea , creare un'istanza del servizio app.
Ottenere il nome host per ogni ambiente.
Verificare che ogni ambiente sia in esecuzione e che la home page sia accessibile.

Annotazioni

Ai fini dell'apprendimento, usare le impostazioni di rete predefinite qui. Queste impostazioni rendono il sito accessibile da Internet. In pratica, è possibile configurare una rete virtuale di Azure che inserisce il sito Web in una rete che non è instradabile su Internet e che solo l'utente e il team possono accedere. Successivamente, è possibile riconfigurare la rete per rendere disponibile il sito Web agli utenti.

Per creare le istanze del servizio app, seguire questa procedura:

Da Cloud Shell generare un numero casuale che rende univoco il nome di dominio dell'app Web.
```
webappsuffix=$RANDOM
```
Per creare un gruppo di risorse denominato tailspin-space-game-rg, eseguire il comando seguente az group create .
```
az group create --name tailspin-space-game-rg
```
Per creare il piano di servizio app denominato tailspin-space-game-asp, eseguire il comando seguente az appservice plan create .
```
az appservice plan create \
  --name tailspin-space-game-asp \
  --resource-group tailspin-space-game-rg \
  --sku B1 \
  --is-linux
```
L'argomento --sku specifica il piano B1. Questo piano funziona sul livello Base. L'argomento --is-linux specifica di usare ruoli di lavoro Linux.

Importante

Se lo SKU B1 non è disponibile nella sottoscrizione di Azure, selezionare un piano diverso, ad esempio S1 (Standard).
Per creare le tre istanze del servizio app, una per ogni ambiente (sviluppo, test e gestione temporanea), eseguire i comandi seguenti az webapp create .
```
az webapp create \
  --name tailspin-space-game-web-dev-$webappsuffix \
  --resource-group tailspin-space-game-rg \
  --plan tailspin-space-game-asp \
  --runtime "DOTNETCORE|8.0"

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

az webapp create \
  --name tailspin-space-game-web-staging-$webappsuffix \
  --resource-group tailspin-space-game-rg \
  --plan tailspin-space-game-asp \
  --runtime "DOTNETCORE|8.0"
```
Ai fini dell'apprendimento, si applica lo stesso piano di servizio app, B1 Basic, a ogni istanza del servizio app qui. In pratica, è necessario assegnare un piano che corrisponda al carico di lavoro previsto.

Ad esempio, per gli ambienti che corrispondono alle fasi di sviluppo e collaudo, B1 Basic potrebbe essere appropriato perché desideri che solo il tuo team possa accedere agli ambienti.

Per l'ambiente di Staging, è necessario selezionare un piano che corrisponda all'ambiente di produzione. Questo piano fornirà probabilmente una maggiore CPU, memoria e risorse di archiviazione. Nel piano è possibile eseguire test delle prestazioni, ad esempio test di carico, in un ambiente simile all'ambiente di produzione. È possibile eseguire i test senza influire sul traffico live verso il sito.

Per elencare il nome host e lo stato di ogni istanza del servizio app, eseguire il comando seguente az webapp list .

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

Prendere nota del nome host per ogni servizio in esecuzione. Questi nomi host sono necessari in un secondo momento quando verifichi il tuo lavoro. Ecco un esempio:

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

Come passaggio facoltativo, passare a uno o più nomi host. Verificare che siano in esecuzione e che venga visualizzata la home page predefinita.

Ecco cosa vedi:

Importante

La pagina Eseguire la pulizia dell'ambiente Azure DevOps di questo modulo contiene una procedura di pulizia importante. La pulizia garantisce che non vengano addebitati costi per le risorse di Azure dopo aver completato questo modulo. Assicurarsi di eseguire la procedura di pulizia anche se non si completa questo modulo.

Creare variabili nelle pipeline di Azure Pipelines

In questa sezione viene aggiunta una variabile per ogni istanza del servizio app che corrisponde a una fase di sviluppo, test o gestione temporanea nella pipeline.

È possibile hardcodificare questi nomi nella configurazione della pipeline, ma se vengono definiti come variabili, la configurazione è maggiormente riutilizzabile. Inoltre, se i nomi delle istanze del servizio app cambiano, è possibile aggiornare le variabili e attivare la pipeline senza modificare la configurazione.

Per aggiungere le variabili:

In Azure DevOps passare al progetto Space Game - Web - Multistage .
In Pipeline selezionare Libreria.
Selezionare + Gruppo di variabili.
In Proprietà immettere Release per il nome del gruppo di variabili.
In Variabili selezionare + Aggiungi.
Per il nome della variabile immettere WebAppNameDev. Per il valore immettere il nome dell'istanza del servizio app corrispondente all'ambiente di sviluppo , ad esempio tailspin-space-game-web-dev-1234.

Ripetere due volte i due passaggi precedenti per creare variabili per gli ambienti di test e gestione temporanea . Ecco alcuni esempi:

Nome variabile	Valore di esempio
WebAppNameTest	tailspin-space-game-web-test-1234
WebAppNameStaging	tailspin-space-game-web-staging-1234

Assicurati di sostituire ogni valore di esempio con l'istanza di App Service che corrisponde al tuo ambiente.

Importante

Impostare il nome dell'istanza del servizio app, non il nome host. In questo esempio si immette tailspin-space-game-web-dev-1234 e non tailspin-space-game-web-dev-1234.azurewebsites.net.

Nella parte superiore della pagina selezionare Salva per salvare la variabile nella pipeline.

Il gruppo di variabili è simile al seguente:

Creare gli ambienti di sviluppo e test

Per creare gli ambienti di sviluppo e test :

Selezionare Ambienti in Azure Pipelines.
Per creare l'ambiente di sviluppo :
1. Selezionare Crea ambiente.
2. In Nome immettere dev.
3. Lasciare i valori predefiniti negli altri campi.
4. Fare clic su Crea.
Per creare l'ambiente di test :
1. Tornare alla pagina Ambienti .
2. Selezionare Nuovo ambiente.
3. In Nome immettere test.
4. Fare clic su Crea.

Creare una connessione al servizio

In questo caso si crea una connessione al servizio che consente ad Azure Pipelines di accedere alla sottoscrizione di Azure. Azure Pipelines usa questa connessione al servizio per distribuire il sito Web nel servizio app. È stata creata una connessione al servizio simile nel modulo precedente.

Importante

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

In Azure DevOps passare al progetto Space Game - Web - Multistage .
Nell'angolo inferiore sinistro della pagina selezionare Impostazioni progetto.
In Pipeline selezionare Connessioni al servizio.
Selezionare Crea connessione al servizio, quindi Selezionare Azure Resource Manager e quindi avanti.
All'inizio della pagina selezionare Registrazione app (automatica). Quindi seleziona Avanti.

Compilare i campi seguenti:

Campo	Valore
Livello di scopo	Abbonamento
Abbonamento	la propria sottoscrizione di Azure
Gruppo di risorse	tailspin-space-game-rg
Nome della connessione al servizio	Resource Manager - Tailspin - Space Game

Durante il processo, potrebbe essere richiesto di accedere all'account Microsoft.

Assicurarsi di selezionare Concedi l'autorizzazione di accesso a tutte le pipeline.
Seleziona Salva.

Per verificare che possa connettersi alla sottoscrizione di Azure, Azure DevOps esegue una connessione di test. Se Azure DevOps non riesce a connettersi, è possibile accedere una seconda volta.

Commenti e suggerimenti

Questa pagina è stata utile?