Esercitazione: Eseguire la distribuzione da GitHub a servizio Azure Kubernetes usando Jenkins
Importante
Molti servizi di Azure dispongono di plug-in Jenkins. Alcuni di questi plug-in non saranno supportati a partire dal 29 febbraio 2024. L'interfaccia della riga di comando di Azure è il modo attualmente consigliato per integrare Jenkins con i servizi di Azure. Per altre informazioni, vedere l'articolo Plug-in Jenkins per Azure.
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:
- Distribuire un'app Azure Vote di esempio in un cluster servizio Azure Kubernetes.
- Creare un progetto di Jenkins di base.
- Configurare le credenziali per Jenkins per l'interazione con il Registro Azure Container.
- Creare un processo di compilazione Jenkins e un webhook GitHub per compilazioni automatizzate.
- Testare la pipeline CI/CD per aggiornare un'applicazione in servizio Azure Kubernetes in base ai commit del codice di GitHub.
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
kubectlconfigurati 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 --versionper 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.
Nota
L'applicazione di voto di Azure di esempio usa un pod di Linux pianificato per l'esecuzione in un nodo di Linux. Il flusso descritto in questo articolo funziona anche per un pod di Windows Server pianificato in un nodo di Windows Server.
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.
$ kubectl get service azure-vote-front --watch
Dopo il passaggio di EXTERNAL-IP da pending a un indirizzo IP, usare Control + C per arrestare il processo kubectl watch.
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
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
Nota
Per installare manualmente AzCLI, seguire queste istruzioni.
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 connettersi al 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_LOGINSERVERe 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
L'output generato dal comando sarà simile all'esempio seguente:
{
"appId": "<app-ID>",
"displayName": "azure-cli-2018-09-28-22-19-34",
"name": "http://azure-cli-2018-09-28-22-19-34",
"password": "<password>",
"tenant": "<tenant-ID>"
}
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:
Immettere azure-vote come nome del processo. Scegliere Freestyle project (Progetto Freestyle) e quindi selezionare OK
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
Nella sezione Gestione del codice sorgente selezionare Git, immettere l'URL del repository
.gitcon fork, ad esempio https://github.com/<your-github-account>/azure-voting-app-redis.gitNella sezione Build Triggers (Trigger di compilazione) selezionare GitHub hook trigger for GITScm polling (Trigger di hook GitHub per polling GITScm).
In Build Environment (Ambiente di compilazione) selezionare Use secret texts or files (Usa testi o file segreti).
In Bindings (Associazioni) selezionare Add (Aggiungi)>Username and password (separated) (Nome utente e password separati).
Immettere
ACR_IDper Username Variable (Variabile nome utente) eACR_PASSWORDper Password Variable (Variabile password).
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_NAMEAggiungere 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_NAMEAl 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:
- Clona il repository GitHub
- Compila una nuova immagine del contenitore
- Esegue il push dell'immagine del contenitore nel Registro Azure Container
- Aggiorna l'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:
Passare al repository GitHub con fork in un Web browser.
Selezionare Impostazioni e quindi Webhook sul lato sinistro.
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.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:
- Il webhook GitHub invia una notifica a Jenkins.
- Jenkins avvia il processo di compilazione ed esegue il pull del commit di codice più recente da GitHub.
- Viene avviata una compilazione di Docker usando il codice aggiornato e la nuova immagine di contenitore è contrassegnata con il numero di build più recente.
- Viene eseguito il push di tale immagine in Registro Azure Container.
- 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:
