Esercitazione: Eseguire la distribuzione da GitHub a servizio Azure Kubernetes usando Jenkins

Questa esercitazione distribuisce un'app di esempio da GitHub in un cluster del servizio Azure Kubernetes (AKS) configurando l'integrazione continua (CI) e la distribuzione continua (CD) in Jenkins.

In questa esercitazione si completeranno le attività seguenti:

Prerequisiti

Per completare questa esercitazione, è necessario quanto segue:

• Conoscenze di base di Kubernetes, Git, CI/CD e delle immagini di contenitore

• Un cluster del servizio Azure Kubernetes e kubectl configurati con le credenziali del cluster del servizio Azure Kubernetes.

• Un registro del servizio Registro Azure Container, il nome del server di accesso al servizio Registro Azure Container e il cluster del servizio Azure Kubernetes configurati per eseguire l'autenticazione con il registro del servizio Registro Azure Container.

• Controller Jenkins distribuito in una macchina virtuale di Azure.

• Interfaccia della riga di comando di Azure versione 2.0.46 o successiva installata e configurata. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

• Docker installato nel sistema di distribuzione in uso

• Un account GitHub, un token di accesso personale a GitHub e un client Git installato nel sistema di distribuzione

• Se si fornisce la propria istanza di Jenkins invece di questo esempio di script per distribuire Jenkins, l'istanza di Jenkins richiede l'installazione e la configurazione di Docker e kubectl.

Preparare l'app

In questo articolo viene usata un'applicazione di voto di Azure di esempio che contiene un'interfaccia Web e Redis per l'archiviazione temporanea dei dati.

Prima di integrare Jenkins e il servizio Azure Kubernetes per le distribuzioni automatizzate, preparare e distribuire l'applicazione di voto di Azure nel cluster servizio Azure Kubernetes. Questa distribuzione manuale consente di visualizzare l'applicazione in azione.

Creare il fork del repository GitHub seguente per l'applicazione esempio - https://github.com/Azure-Samples/azure-voting-app-redis. Per creare il fork del repository nel proprio account GitHub, selezionare il pulsante Fork nell'angolo superiore destro.

Clonare il fork nel proprio sistema di sviluppo. Verificare di usare l'URL del fork durante la clonazione del repository:

git clone https://github.com/<your-github-account>/azure-voting-app-redis.git

Passare alla directory del fork clonato:

cd azure-voting-app-redis

Per creare le immagini di contenitore necessarie per l'applicazione di esempio, usare il file docker-compose.yaml con docker-compose:

docker-compose up -d

Viene eseguito il pull delle immagini di base necessarie e vengono compilati i contenitori dell'applicazione. È quindi possibile usare il comando docker images per visualizzare l'immagine creata. Sono state scaricate o create tre immagini. L'immagine azure-vote-front contiene l'applicazione e usa l'immagine nginx-flask come base. L'immagine redis viene usata per avviare un'istanza di Redis:

$ docker images

REPOSITORY                   TAG        IMAGE ID            CREATED             SIZE
azure-vote-front             latest     9cc914e25834        40 seconds ago      694MB
redis                        latest     a1b99da73d05        7 days ago          106MB
tiangolo/uwsgi-nginx-flask   flask      788ca94b2313        9 months ago        694MB

Accedere al Registro Azure Container.

az acr login -n <acrLoginServer>

Sostituire <acrLoginServer> con il server di accesso del Registro Azure Container.

Usare il comando docker tag per assegnare tag all'immagine con il nome del server di accesso di Registro Azure Container e il numero di versione v1. Usare il proprio <acrLoginServer> nome ottenuto nel passaggio precedente:

docker tag azure-vote-front <acrLoginServer>/azure-vote-front:v1

Eseguire infine il push dell'immagine azure-vote-front in Registro Azure Container. Anche in questo caso, sostituire <acrLoginServer> con il nome del server di accesso di Registro Azure Container, ad esempio myacrregistry.azurecr.io:

docker push <acrLoginServer>/azure-vote-front:v1

Distribuire l'applicazione di esempio nel servizio Azure Kubernetes

Per distribuire l'applicazione di esempio nel cluster servizio Azure Kubernetes, è possibile usare il file manifesto Kubernetes nella radice del repository di voto di Azure. Aprire il azure-vote-all-in-one-redis.yaml file manifesto con un editor, viad esempio . Sostituire microsoft con il nome del server di accesso di Registro Azure Container. Questo valore viene trovato nella riga 60 del file manifesto:

containers:
- name: azure-vote-front
  image: azuredocs/azure-vote-front

Successivamente, usare il comando kubectl apply per distribuire l'applicazione nel cluster del servizio Azure Kubernetes:

kubectl apply -f azure-vote-all-in-one-redis.yaml

Viene creato un servizio di bilanciamento del carico di Kubernetes per esporre l'applicazione a Internet. Questo processo può richiedere alcuni minuti. Per monitorare l'avanzamento della distribuzione del servizio di bilanciamento del carico, usare il comando kubectl get service con l'argomento --watch. Dopo il passaggio di EXTERNAL-IP da pending a un indirizzo IP, usare Control + C per arrestare il processo kubectl watch.

$ kubectl get service azure-vote-front --watch

NAME               TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
azure-vote-front   LoadBalancer   10.0.215.27   <pending>     80:30747/TCP   22s
azure-vote-front   LoadBalancer   10.0.215.27   40.117.57.239   80:30747/TCP   2m

Per vedere l'applicazione in azione, aprire un Web browser all'indirizzo IP esterno del servizio. Viene visualizzata l'applicazione di voto di Azure, come illustrato nell'esempio seguente:

Configurare il controller Jenkins

Applicare le modifiche seguenti per abilitare le distribuzioni del servizio Azure Kubernetes dal controller Jenkins:

Aprire la porta 80 in ingresso.

az vm open-port \
--resource-group <Resource_Group_name> \
--name <Jenkins_Controller_VM>  \
--port 80 --priority 1020

Sostituire <Resource_Group_name> e <Jenkins_Controller_VM> con i valori appropriati.

SSH nel controller Jenkins

ssh azureuser@<PublicIPAddres>

Sostituire <PublicIPAddress> con l'indirizzo IP del controller Jenkins.

Installare e accedere ad AzCLI

curl -L https://aka.ms/InstallAzureCli | bash

az login

Installare Docker

sudo apt-get install apt-transport-https ca-certificates curl software-properties-common -y;
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -;
sudo apt-key fingerprint 0EBFCD88;
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable";
sudo apt-get update;
sudo apt-get install docker-ce -y;

Installare Kubectl e Connessione nel servizio Azure Kubernetes

sudo az aks install-cli
sudo az aks get-credentials --resource-group <Resource_Group> --name <AKS_Name>

Sostituire <Resource_Group> e <AKS_Name> con i valori appropriati.

Configurare l'accesso

sudo usermod -aG docker jenkins;
sudo usermod -aG docker azureuser;
sudo touch /var/lib/jenkins/jenkins.install.InstallUtil.lastExecVersion;
sudo service jenkins restart;
sudo cp ~/.kube/config /var/lib/jenkins/.kube/
sudo chmod 777 /var/lib/jenkins/
sudo chmod 777 /var/lib/jenkins/config

Creare una variabile di ambiente di Jenkins

Per contenere il nome del server di accesso di Registro Azure Container, viene usata una variabile di ambiente di Jenkins. A tale variabile viene fatto riferimento durante il processo di compilazione di Jenkins. Per creare questa variabile di ambiente, completare i passaggi seguenti:

• Nella parte sinistra del portale di Jenkins selezionare Manage Jenkins>Configure System (Gestisci Jenkins > Configura sistema)

• In Global Properties (Proprietà globali) selezionare Environment variables (Variabili di ambiente). Aggiungere una variabile con il nome ACR_LOGINSERVER e il valore del server di accesso di Registro Azure Container in uso.

  

• Al termine, selezionare Salva nella parte inferiore della pagina.

Creare una credenziale di Jenkins per il Registro Azure Container

Durante il processo CI/CD, Jenkins compila nuovi immagini del contenitore in base agli aggiornamenti delle applicazioni e deve quindi eseguire il push di tali immagini in Registro Azure Container.

Per consentire a Jenkins di eseguire il push delle immagini del contenitore aggiornate in Registro Azure Container, è necessario specificare le credenziali per Registro Azure Container.

Per la separazione dei ruoli e delle autorizzazioni, configurare un'entità servizio per Jenkins con autorizzazioni di collaboratore per il Registro Azure Container.

Creare un'entità servizio per Jenkins per usare il Registro Azure Container

Creare in primo luogo un'entità servizio usando il comando az ad sp create-for-rbac:

az ad sp create-for-rbac

{
  "appId": "626dd8ea-042d-4043-a8df-4ef56273670f",
  "displayName": "azure-cli-2018-09-28-22-19-34",
  "name": "http://azure-cli-2018-09-28-22-19-34",
  "password": "1ceb4df3-c567-4fb6-955e-f95ac9460297",
  "tenant": "72f988bf-86f1-41af-91ab-2d7cd011db48"
}

Prendere nota di appId e password. Tali valori vengono usati nella procedura seguente per configurare la risorsa credenziale in Jenkins.

Ottenere l'ID risorsa di Registro Azure Container usando il comando az acr show e archiviarlo come variabile.

ACR_ID=$(az acr show --resource-group <Resource_Group> --name <acrLoginServer> --query "id" --output tsv)

Sostituire <Resource_Group> e <acrLoginServer> con i valori appropriati.

Creare un'assegnazione di ruolo per assegnare i diritti di Collaboratore dell'entità servizio al Registro Azure Container.

az role assignment create --assignee <appID> --role Contributor --scope $ACR_ID

Sostituire <appId> con il valore fornito nell'output del comando pervious usare per creare l'entità servizio.

Creare una risorsa credenziale in Jenkins per l'entità servizio del servizio Registro Azure Container

Con l'assegnazione di ruolo creata in Azure, archiviare le credenziali di Registro Azure Container in un oggetto credenziale di Jenkins. Durante il processo di compilazione di Jenkins si farà riferimento a queste credenziali.

Tornare sul lato sinistro del portale di Jenkins, selezionare Gestisci jenkins>Gestisci credenziali>Jenkins Store>Global credentials (senza restrizioni)Add Credentials (Aggiungi credenziali)>

Verificare che il tipo di credenziali sia Username with password (Nome utente con password) e immettere gli elementi seguenti:

• Nome utente - appId dell'entità servizio creata per l'autenticazione con il Registro Azure Container.
• Password - password dell'entità utente creata per l'autenticazione con il Registro Azure Container.
• ID - identificatore di credenziali, ad esempio acr-credentials

Al termine, il modulo delle credenziali è analogo all'esempio seguente:

Selezionare OK e tornare al portale di Jenkins.

Creare un progetto di Jenkins

Nella home page del portale di Jenkins selezionare New item (Nuovo elemento) nella parte sinistra:

1. Immettere azure-vote come nome del processo. Scegliere Freestyle project (Progetto Freestyle) e quindi selezionare OK

2. Nella sezione Generale selezionare Progetto GitHub e immettere l'URL del repository con fork, ad esempio https://github.com/<your-github-account>/azure-voting-app-redis

3. Nella sezione Gestione del codice sorgente selezionare Git, immettere l'URL del repository .git con fork, ad esempio https://github.com/<your-github-account>/azure-voting-app-redis.git

4. Nella sezione Build Triggers (Trigger di compilazione) selezionare GitHub hook trigger for GITScm polling (Trigger di hook GitHub per polling GITScm).

5. In Build Environment (Ambiente di compilazione) selezionare Use secret texts or files (Usa testi o file segreti).

6. In Bindings (Associazioni) selezionare Add (Aggiungi)>Username and password (separated) (Nome utente e password separati).

   • Immettere ACR_ID per Username Variable (Variabile nome utente) e ACR_PASSWORD per Password Variable (Variabile password).

     

7. Aggiungere un'istruzione di compilazione di tipo Execute shell (Esegui shell) e usare il testo seguente. Questo script compila una nuova immagine del contenitore e la inserisce nel Registro Azure Container.

   # Build new image and push to ACR.
   WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}"
   docker build -t $WEB_IMAGE_NAME ./azure-vote
   docker login ${ACR_LOGINSERVER} -u ${ACR_ID} -p ${ACR_PASSWORD}
   docker push $WEB_IMAGE_NAME
   

8. Aggiungere un'altra istruzione di compilazione di tipo Execute shell (Esegui shell) e usare il testo seguente. Questo script aggiorna la distribuzione dell'applicazione nel servizio Azure Kubernetes con la nuova immagine del contenitore da Registro Azure Container.

   # Update kubernetes deployment with new image.
   WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}"
   kubectl set image deployment/azure-vote-front azure-vote-front=$WEB_IMAGE_NAME
   

9. Al termine, fare clic su Save (Salva).

Testare la build di Jenkins

Prima di automatizzare il processo in base ai commit di GitHub, testare manualmente la compilazione jenkins.

Questa compilazione verifica che il processo sia stato configurato correttamente. Conferma che il file di autenticazione Kubernetes appropriato è attivo e che l'autenticazione in Registro Azure Container funziona.

Nel menu a sinistra del progetto selezionare Build Now (Compila).

La prima compilazione è più lunga quando i livelli di immagine Docker vengono trascinati verso il basso nel server Jenkins.

Le compilazioni eseguono le attività seguenti:

1. Clona il repository GitHub
2. Compila una nuova immagine del contenitore
3. Esegue il push dell'immagine del contenitore nel Registro Azure Container
4. Aggiornamenti'immagine usata dalla distribuzione del servizio Azure Kubernetes

Poiché non sono state apportate modifiche al codice dell'applicazione, l'interfaccia utente Web rimane invariata.

Al termine del processo di compilazione, selezionare build #1 nella cronologia di compilazione. Selezionare Console output (Output console) e visualizzare l'output del processo di compilazione. La riga finale deve indicare che la build ha avuto esito positivo.

Creare un webhook GitHub

Dopo aver completato la compilazione manuale, integrare GitHub nella compilazione Jenkins. Usare un webhook per eseguire il processo di compilazione Jenkins ogni volta che viene eseguito il commit del codice in GitHub.

Per creare il webhook GitHub, completare questi passaggi:

1. Passare al repository GitHub con fork in un Web browser.

2. Selezionare Impostazioni e quindi Webhook sul lato sinistro.

3. Scegli Aggiungi webhook. Come valore per Payload URL (URL di payload) immettere http://<publicIp:8080>/github-webhook/ dove <publicIp> è l'indirizzo IP del server di Jenkins. Assicurarsi di includere l'oggetto finale /. Lasciare le altre impostazioni predefinite per il tipo di contenuto e attivare gli eventi push.

4. Selezionare Aggiungi webhook.

   

Testare la pipeline CI/CD completata

È ora possibile testare l'intera pipeline di integrazione CI/CD. Quando si esegue il push di un commit di codice da GitHub, vengono eseguite queste operazioni:

1. Il webhook GitHub invia una notifica a Jenkins.
2. Jenkins avvia il processo di compilazione ed esegue il pull del commit di codice più recente da GitHub.
3. Viene avviata una compilazione di Docker usando il codice aggiornato e la nuova immagine di contenitore è contrassegnata con il numero di build più recente.
4. Viene eseguito il push di tale immagine in Registro Azure Container.
5. L'applicazione in esecuzione in servizio Azure Kubernetes aggiornamenti con l'immagine più recente di Registro Azure Container.

Nel computer di sviluppo aprire l'applicazione clonata con un editor di codice. Nella directory /azure-vote/azure-vote aprire il file denominato config_file.cfg. Aggiornare i valori di voto in questo file su un valore rilevante, come illustrato nell'esempio seguente:

# UI Configurations
TITLE = 'Azure Voting App'
VOTE1VALUE = 'Blue'
VOTE2VALUE = 'Purple'
SHOWHOST = 'false'

Quando viene aggiornato, salvare il file, eseguire il commit delle modifiche ed eseguirne il push nel fork del repository GitHub. Il webhook GitHub attiva un nuovo processo di compilazione in Jenkins. Nel dashboard Web di Jenkins monitorare il processo di compilazione. Sono necessari pochi secondi per eseguire il pull del codice più recente, creare ed eseguire il push dell'immagine aggiornata e distribuire l'applicazione aggiornata nel servizio Azure Kubernetes.

Al termine della compilazione, aggiornare il Web browser dell'applicazione di voto di Azure di esempio. Le modifiche vengono visualizzate, come illustrato nell'esempio seguente:

Passaggi successivi