Integrazione di Jenkins con il servizio contenitore di Azure e KubernetesJenkins integration with Azure Container Service and Kubernetes

Avviso

Si sta visualizzando la documentazione per la versione precedente del servizio contenitore di Azure.You are viewing documentation for the old version of the Azure Container Service. Il servizio contenitore di Azure è in fase di aggiornamento con l'aggiunta di nuove opzioni di distribuzione, funzionalità di gestione migliorate e vantaggi economici in Kubernetes in Azure.Azure Container Service (AKS) is being updated to add new deployment options, enhanced management capabilities, and cost benefit to Kubernetes on Azure. Per iniziare a usare tali funzionalità in anteprima, vedere AKS documentation (Documentazione del servizio contenitore di Azure).Visit the AKS documentation to start working with these preview features.

Questa esercitazione illustra il processo per impostare l'integrazione continuata di un'applicazione multi-contenitore nel servizio contenitore di Azure Kubernetes usando la piattaforma Jenkins.In this tutorial, we walk through the process to set up continuous integration of a multi-container application into Azure Container Service Kubernetes using the Jenkins platform. Il flusso di lavoro aggiorna l'immagine del contenitore in Docker Hub e i podcast Kubernetes implementando la distribuzione.The workflow updates the container image in Docker Hub and upgrades the Kubernetes pods using a deployment rollout.

Processo principaleHigh level process

I passaggi di base descritti in questo articolo sono:The basic steps detailed in this article are:

  • Installare un cluster Kubernetes nel servizio contenitoreInstall a Kubernetes cluster in Container Service
  • Impostare Jenkins e configurare l'accesso al servizio contenitoreSet up Jenkins and configure access to Container Service
  • Creare un flusso di lavoro JenkinsCreate a Jenkins workflow
  • Testare il processo CI/CD end-to-endTest the CI/CD process end to end

Installare un cluster KubernetesInstall a Kubernetes cluster

Distribuire il cluster Kubernetes nel servizio contenitore di Azure seguendo questi passaggi.Deploy the Kubernetes cluster in Azure Container Service using the following steps. La documentazione completa è disponibile qui.Full documentation is located here.

Passaggio 1: Creare un gruppo di risorseStep 1: Create a resource group

RESOURCE_GROUP=my-resource-group
LOCATION=westus

az group create --name=$RESOURCE_GROUP --location=$LOCATION

Passaggio 2: Distribuire il clusterStep 2: Deploy the cluster

Nota

Le operazioni seguenti richiedono una chiave pubblica SSH locale archiviata nella cartella ~/.ssh.The following steps require a local SSH public key stored in the ~/.ssh folder.

RESOURCE_GROUP=my-resource-group
DNS_PREFIX=some-unique-value
CLUSTER_NAME=any-acs-cluster-name

az acs create \
--orchestrator-type=kubernetes \
--resource-group $RESOURCE_GROUP \
--name=$CLUSTER_NAME \
--dns-prefix=$DNS_PREFIX \
--ssh-key-value ~/.ssh/id_rsa.pub \
--admin-username=azureuser \
--master-count=1 \
--agent-count=5 \
--agent-vm-size=Standard_D1_v2

Impostare Jenkins e configurare l'accesso al servizio contenitoreSet up Jenkins and configure access to Container Service

Passaggio 1: Installare JenkinsStep 1: Install Jenkins

  1. Creare una macchina virtuale di Azure con Ubuntu 16.04 LTS.Create an Azure VM with Ubuntu 16.04 LTS. Poiché in seguito in questa procedura sarà necessario connettersi a questa VM mediante bash nel computer locale, impostare "Tipo di autenticazione" su "Chiave pubblica SSH" e incollare la chiave pubblica SSH archiviata localmente nella cartella ~/.ssh.Since later in the steps you will need to connect to this VM using bash on your local machine, set the 'Authentication type' to 'SSH public key' and paste the SSH public key that is stored locally in your ~/.ssh folder. Inoltre, prendere nota del "Nome utente" che si specifica poiché sarà necessario per visualizzare il dashboard Jenkins e per la connessione alla VM Jenkins nei passaggi successivi.Also, take note of the 'User name' that you specify since this user name will be needed to view the Jenkins dashboard and for connecting to the Jenkins VM in later steps.
  2. Installare Jenkins tramite queste istruzioni.Install Jenkins via these instructions. Un'esercitazione più dettagliata è disponibile all'indirizzo howtoforge.com.A more detailed tutorial is at howtoforge.com.
  3. Per visualizzare il dashboard Jenkins sul computer locale, aggiornare il gruppo di sicurezza di rete di Azure per consentire la porta 8080 mediante l'aggiunta di una regola in ingresso che consente l'accesso alla porta 8080.To view the Jenkins dashboard on your local machine, update the Azure network security group to allow port 8080 by adding an inbound rule that allows access to port 8080. In alternativa è possibile impostare il port forwarding eseguendo questo comando: ssh -i ~/.ssh/id_rsa -L 8080:localhost:8080 <your_jenkins_user>@<your_jenkins_public_ipAlternatively, you may setup port forwarding by running this command: ssh -i ~/.ssh/id_rsa -L 8080:localhost:8080 <your_jenkins_user>@<your_jenkins_public_ip
  4. Connettersi al server Jenkins mediante il browser accedendo all'indirizzo IP pubblico (http://<your_jenkins_public_ip>:8080) e sbloccare il dashboard Jenkins per la prima volta con la password di amministrazione iniziale.Connect to your Jenkins server using the browser by navigating to the public IP (http://<your_jenkins_public_ip>:8080) and unlock the Jenkins dashboard for the first time with the initial admin password. La password di amministrazione iniziale è archiviata in /var/lib/jenkins/secrets/initialAdminPassword nella VM Jenkins.The admin password is stored at /var/lib/jenkins/secrets/initialAdminPassword on the Jenkins VM. Un modo semplice per ottenere la password è stabilire una connessione SSH alla VM Jenkins: ssh <your_jenkins_user>@<your_jenkins_public_ip>.An easy way to get this password is to SSH into the Jenkins VM: ssh <your_jenkins_user>@<your_jenkins_public_ip>. Quindi eseguire: sudo cat /var/lib/jenkins/secrets/initialAdminPassword.Next, run: sudo cat /var/lib/jenkins/secrets/initialAdminPassword.
  5. Installare Docker nel computer Jenkins tramite queste istruzioni.Install Docker on the Jenkins machine via these instructions. In questo modo è possibile eseguire comandi Docker nei processi Jenkins.This allows for Docker commands to be run in Jenkins jobs.
  6. Configurare le autorizzazioni di Docker per consentire a Jenkins di accedere all'endpoint Docker.Configure Docker permissions to allow Jenkins to access the Docker endpoint.

    sudo chmod 777 /run/docker.sock
    
  7. Installare l'interfaccia della riga di comando kubectl in Jenkins.Install kubectl CLI on Jenkins. Altre informazioni sono disponibili leggendo l'articolo sull'installazione e la configurazione di kubectl.More details are at Installing and Setting up kubectl. I processi di Jenkins useranno "kubectl" per gestire e distribuire il cluster Kubernetes.Jenkins jobs will use 'kubectl' to manage and deploy to the Kubernetes cluster.

    curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
    
    chmod +x ./kubectl
    
    sudo mv ./kubectl /usr/local/bin/kubectl
    

Passaggio 2: Impostare l'accesso al cluster KubernetesStep 2: Set up access to the Kubernetes cluster

Nota

Esistono diversi approcci per eseguire la procedura seguente.There are multiple approaches to accomplishing the following steps. Usare l'approccio che si ritiene più semplice.Use the approach that is easiest for you.

  1. Copiare il file di configurazione kubectl nel computer Jenkins, in modo che i processi Jenkins abbiano accesso al cluster Kubernetes.Copy the kubectl config file to the Jenkins machine so that Jenkins jobs have access to the Kubernetes cluster. Queste istruzioni presuppongono che si usi bash da un computer diverso rispetto alla VM Jenkins e che una chiave pubblica SSH locale sia archiviata nella cartella ~/.ssh del computer.These instructions assume that you are using bash from a different machine than the Jenkins VM and that a local SSH public key is stored in the machine's ~/.ssh folder.
export KUBE_MASTER=<your_cluster_master_fqdn>
export JENKINS_USER=<your_jenkins_user>
export JENKINS_SERVER=<your_jenkins_public_ip>
sudo ssh $JENKINS_USER@$JENKINS_SERVER sudo mkdir -m 777 /home/$JENKINS_USER/.kube/ \
&& sudo ssh $JENKINS_USER@$JENKINS_SERVER sudo mkdir /var/lib/jenkins/.kube/ \
&& sudo scp -3 -i ~/.ssh/id_rsa azureuser@$KUBE_MASTER:.kube/config $JENKINS_USER@$JENKINS_SERVER:~/.kube/config \
&& sudo ssh -i ~/.ssh/id_rsa $JENKINS_USER@$JENKINS_SERVER sudo cp /home/$JENKINS_USER/.kube/config /var/lib/jenkins/.kube/config \
  1. Da Jenkins, verificare che il cluster Kubernetes sia accessibile.Validate from Jenkins that the Kubernetes cluster is accessible. A tale scopo, eseguire una connessione SSH alla VM Jenkins: ssh <your_jenkins_user>@<your_jenkins_public_ip>.To do this, SSH into the Jenkins VM: ssh <your_jenkins_user>@<your_jenkins_public_ip>. Quindi verificare che Jenkins possa connettersi al cluster: kubectl cluster-info.Next, verify Jenkins can successfully connect to your cluster: kubectl cluster-info.

Creare un flusso di lavoro JenkinsCreate a Jenkins workflow

PrerequisitiPrerequisites

  • Account GitHub per il repository di codice.GitHub account for code repo.
  • Account Docker Hub per archiviare e aggiornare le immagini.Docker Hub account to store and update images.
  • Applicazione in contenitore, ricompilabile e aggiornabile.Containerized application that can be rebuilt and updated. È possibile usare questa applicazione contenitore di esempio scritta in Golang: https://github.com/chzbrgr71/go-webYou can use this sample container app written in Golang: https://github.com/chzbrgr71/go-web

Nota

Eseguire i passaggi seguenti nel proprio account GitHub.The following steps must be performed in your own GitHub account. È possibile clonare il repository precedente, ma è necessario usare il proprio account per configurare i webhook e l'accesso a Jenkins.Feel free to clone the above repo, but you must use your own account to configure the webhooks and Jenkins access.

Passaggio 1: Distribuire la versione 1 iniziale dell'applicazioneStep 1: Deploy initial v1 of application

  1. Compilare l'applicazione dal computer per lo sviluppo con i comandi seguenti.Build the app from the developer machine with the following commands. Sostituire myrepo con la propria.Replace myrepo with your own.

    git clone https://github.com/chzbrgr71/go-web.git
    cd go-web
    docker build -t myrepo/go-web .
    
  2. Inviare l'immagine a Docker Hub.Push image to Docker Hub.

    docker login
    docker push myrepo/go-web
    
  3. Distribuire nel cluster Kubernetes.Deploy to the Kubernetes cluster.

    Nota

    Modificare il file go-web.yaml per aggiornare l'immagine del contenitore e il repository.Edit the go-web.yaml file to update your container image and repo.

    kubectl create -f ./go-web.yaml --record
    

    Passaggio 2: Configurare il sistema JenkinsStep 2: Configure Jenkins system

  4. Fare clic su Manage Jenkins (Gestisci Jenkins) > Configure System (Configura sistema).Click Manage Jenkins > Configure System.
  5. In GitHubselezionare Add GitHub Server (Aggiungi server GitHub).Under GitHub, select Add GitHub Server.
  6. Lasciare il campo API URL come predefinito.Leave API URL as default.
  7. In Credenziali, aggiungere una credenziale Jenkins usando Secret text (Testo segreto).Under Credentials, add a Jenkins credential using Secret text. Si consiglia di usare i token di accesso a GitHub personali, configurati nelle impostazioni dell'account utente GitHub.We recommend using GitHub personal access tokens, which are configured in your GitHub user account settings. Altre informazioni a riguardo sono disponibili qui.More details on this here.
  8. Fare clic su Connessione di test per assicurarsi che la configurazione sia stata eseguita correttamente.Click Test connection to ensure this is configured correctly.
  9. In Proprietà globali aggiungere una variabile di ambiente DOCKER_HUB e indicare la password di Docker Hub.Under Global Properties, add an environment variable DOCKER_HUB and provide your Docker Hub password. Questa operazione è utile per questa demo, ma uno scenario di produzione richiederà un approccio più sicuro.(This is useful in this demo, but a production scenario would require a more secure approach.)
  10. Salvare.Save.

Accesso GitHub a Jenkins

Passaggio 3: Creare il flusso di lavoro JenkinsStep 3: Create the Jenkins workflow

  1. Creare un elemento Jenkins.Create a Jenkins item.
  2. Specificare un nome (ad esempio, "go-web") e selezionare Freestyle Project (Progetto Freestyle).Provide a name (for example, "go-web") and select Freestyle Project.
  3. Controllare GitHub project (Progetto GitHub) e indicare l'URL del repository di GitHub.Check GitHub project and provide the URL to your GitHub repo.
  4. In Source Code Management (Gestione codice sorgente) fornire l'URL e le credenziali del repository di GitHub.In Source Code Management, provide the GitHub repo URL and credentials.
  5. Aggiungere un'istruzione di compilazione di tipo Esegui shell e usare il seguente testo:Add a Build Step of type Execute shell and use the following text:

    WEB_IMAGE_NAME="myrepo/go-web:kube${BUILD_NUMBER}"
    docker build -t $WEB_IMAGE_NAME .
    docker login -u <your-dockerhub-username> -p ${DOCKER_HUB}
    docker push $WEB_IMAGE_NAME
    
  6. Aggiungere un'altra istruzione di compilazione di tipo Esegui shell e usare il seguente testo:Add another Build Step of type Execute shell and use the following text:

    WEB_IMAGE_NAME="myrepo/go-web:kube${BUILD_NUMBER}"
    kubectl set image deployment/go-web go-web=$WEB_IMAGE_NAME --kubeconfig /var/lib/jenkins/config
    

Passaggi di compilazione in Jenkins

  1. Salvare l'elemento Jenkins e testarlo con Build Now (Compila ora).Save the Jenkins item and test with Build Now.

Passaggio 4: Connettere il webhook GitHubStep 4: Connect GitHub webhook

  1. Nell'elemento di Jenkins creato fare clic su Configura.In the Jenkins item you created, click Configure.
  2. In Build Triggers (Trigger di compilazione), selezionare l'opzione GitHub hook trigger for GITScm polling (Trigger di hook GitHub per polling GITScm) e salvare.Under Build Triggers, select GitHub hook trigger for GITScm polling and Save. Verrà automaticamente configurato il webhook GitHub.This automatically configures the GitHub webhook.
  3. Nel repository di GitHub per go-web, fare clic su Impostazioni > Webhook.In your GitHub repo for go-web, click Settings > Webhooks.
  4. Verificare che l'URL del webhook Jenkins sia stato aggiunto correttamente.Verify that the Jenkins webhook URL was added successfully. L'URL deve terminare con "github-webhook".The URL should end in "github-webhook".

Configurazione del webhook Jenkins

Testare il processo CI/CD end-to-endTest the CI/CD process end to end

  1. Aggiornare il codice per il repository ed eseguire il push/sincronizzazione con il repository di GitHub.Update code for the repo and push/synch with the GitHub repository.
  2. Dalla console Jenkins, controllare la Build History (Cronologia compilazione) e verificare l'esecuzione corretta del processo.From the Jenkins console, check the Build History and validate that the job has run. Visualizzazione l'output della console per i dettagli.View console output to see details.
  3. Da Kubernetes, visualizzare i dettagli della distribuzione aggiornata:From Kubernetes, view details of the upgraded deployment:

    kubectl rollout history deployment/go-web
    

Passaggi successiviNext steps

  • Distribuire un Registro di sistema del contenitore di Azure e archiviare le immagini in un repository sicuro.Deploy Azure Container Registry and store images in a secure repository. Vedere la documentazione sul Registro di sistema del contenitore di Azure.See Azure Container Registry docs.
  • Creare un flusso di lavoro più complesso che includa la distribuzione affiancata e i test automatizzati in Jenkins.Build a more complex workflow that includes side-by-side deployment and automated tests in Jenkins.
  • Per ulteriori informazioni su CI/CD con Jenkins e Kubernetes, vedere il blog su Jenkins.For more information about CI/CD with Jenkins and Kubernetes, see the Jenkins blog.