Självstudie: Distribuera från GitHub till Azure Kubernetes Service med Jenkins

Den här självstudien distribuerar en exempelapp från GitHub till ett Azure Kubernetes Service-kluster (AKS) genom att konfigurera kontinuerlig integrering (CI) och kontinuerlig distribution (CD) i Jenkins.

I den här självstudien får du utföra följande uppgifter:

Förutsättningar

För att slutföra den här självstudien behöver du följande objekt:

• Grundläggande förståelse för Kubernetes-, Git-, CI/CD- och containeravbildningar

• Ett AKS-kluster och konfigurerat med autentiseringsuppgifterna för AKS-klustret.

• Ett Azure Container Registry (ACR), namnet på ACR-inloggningsservern och det AKS-kluster som konfigurerats för att autentisera med ACR-registret.

• En Jenkins-styrenhet som distribuerats till en virtuell Azure-dator.

• Azure CLI version 2.0.46 eller senare installeras och konfigureras. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

• Docker installerat på ditt utvecklingssystem

• Ett GitHub-konto, GitHub personlig åtkomsttokenoch En Git-klient som är installerad på ditt utvecklingssystem

• Om du anger en egen Jenkins-instans i stället för det här exempelskriptet för att distribuera Jenkins måste Jenkins-instansen ha Docker installerat och konfigurerat och kubectl.

Förbereda din app

I den här artikeln använder du ett Azure Vote-exempelprogram som innehåller ett webbgränssnitt och Redis för tillfällig datalagring.

Innan du integrerar Jenkins och AKS för automatiserade distributioner måste du först manuellt förbereda och distribuera Azure Vote-programmet till ditt AKS-kluster. Med den här manuella distributionen kan du se hur programmet används.

Förförför följande GitHub för exempelprogrammet – https://github.com/Azure-Samples/azure-voting-app-redis . Om du vill förgrena lagringsplatsen till ditt eget GitHub-konto väljer du knappen Fork (Förgrening) i det övre högra hörnet.

Klona föringarna till ditt utvecklingssystem. Se till att du använder URL:en för din föring när du klonar den här lagringsplatsen:

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

Ändra till katalogen för din klonade föring:

cd azure-voting-app-redis

Om du vill skapa containeravbildningarna som behövs för exempelprogrammet använder du filen docker-compose.yaml med :

docker-compose up -d

De nödvändiga basavbildningarna hämtas och programcontainrarna byggs. Du kan sedan använda kommandot docker images för att se den skapade avbildningen. Tre avbildningar har hämtats eller skapats. azure-vote-front-avbildningen innehåller programmet och använder nginx-flask-avbildningen som bas. redisAvbildningen används för att starta en Redis-instans:

$ 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

Logga in på ditt Azure-containerregister.

az acr login -n <acrLoginServer>

Ersätt <acrLoginServer> med din ACR-inloggningsserver.

Använd kommandot docker tag för att tagga avbildningen med namnet på ACR-inloggningsservern och versionsnumret . Använd ditt eget <acrLoginServer> namn som du fick i föregående steg:

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

Slutligen push-push-pushar du avbildningen azure-vote-front till ditt ACR-register. Ersätt återigen <acrLoginServer> med inloggningsservernamnet för ditt eget ACR-register, till exempel myacrregistry.azurecr.io :

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

Distribuera exempelprogrammet till AKS

Om du vill distribuera exempelprogrammet till ditt AKS-kluster kan du använda Kubernetes-manifestfilen i roten på lagringsplatsen Azure Vote. Öppna azure-vote-all-in-one-redis.yaml manifestfilen med ett redigeringsprogram som vi . Ersätt microsoft med namnet på din ACR-inloggningsserver. Det här värdet finns på rad 60 i manifestfilen:

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

Använd sedan kommandot kubectl apply för att distribuera programmet till ditt AKS-kluster:

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

En Kubernetes-lastbalanseringstjänst skapas för att exponera programmet för Internet. Den här processen kan ta några minuter. Om du vill övervaka förloppet för distributionen av lastbalanseraren använder du kommandot kubectl get service med argumentet . När EXTERNAL-IP-adressen har ändrats från pending till en IP-adress använder du för att stoppa kubectl-övervakningsprocessen.

$ 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

Om du vill se hur programmet fungerar i praktiken öppnar du en webbläsare till den externa IP-adressen för din tjänst. Azure Vote-programmet visas, som du ser i följande exempel:

Konfigurera Jenkins-kontrollanten

Tillämpa följande ändringar för att aktivera AKS-distributioner från Jenkins-kontrollanten:

Öppna 80 inkommande portar.

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

Ersätt <Resource_Group_name> och med lämpliga <Jenkins_Controller_VM> värden.

SSH till Jenkins-kontrollanten

ssh azureuser@<PublicIPAddres>

Ersätt <PublicIPAddress> med IP-adressen för Jenkins-styrenheten.

Installera & logga in på AzCLI

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

az login

Installera 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;

Installera Kubectl och Anslut till AKS

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

Ersätt <Resource_Group> och med lämpliga <AKS_Name> värden.

Konfigurera åtkomst

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

Skapa en Jenkins-miljövariabel

En Jenkins-miljövariabel används för att innehålla namnet på ACR-inloggningsservern. Den här variabeln refereras under Jenkins-byggjobbet. Skapa miljövariabeln genom att utföra följande steg:

• Till vänster i Jenkins-portalen väljer du Hantera JenkinsKonfigurera system

• Under Globala egenskaperväljer du Miljövariabler. Lägg till en variabel med namnet ACR_LOGINSERVER och värdet för din ACR-inloggningsserver.

  

• När du är klar väljer du Spara längst ned på sidan.

Skapa jenkins-autentiseringsuppgifter för ACR

Under CI/CD-processen skapar Jenkins nya containeravbildningar baserat på programuppdateringar och måste sedan skicka avbildningarna till ACR-registret.

Om du vill tillåta Jenkins att skicka uppdaterade containeravbildningar till ACR måste du ange autentiseringsuppgifter för ACR.

Om du vill separera roller och behörigheter konfigurerar du ett huvudnamn för tjänsten för Jenkins med deltagarbehörighet till ditt ACR-register.

Skapa ett huvudnamn för tjänsten för Jenkins för att använda ACR

Skapa först ett huvudnamn för tjänsten med kommandot 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"
}

Anteckna värdena för appId och password. Dessa värden används i följande steg för att konfigurera autentiseringsresursen i Jenkins.

Hämta resurs-ID:t för ditt ACR-register med kommandot az acr show och lagra det som en variabel.

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

Ersätt <Resource_Group> och med lämpliga <acrLoginServer> värden.

Skapa en rolltilldelning för att tilldela behörigheterna för tjänstens huvudnamnsdeltagare till ACR-registret.

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

Ersätt <appId> med värdet som anges i utdata från det föregående kommandot för att skapa tjänstens huvudnamn.

Skapa en autentiseringsresurs i Jenkins för ACR-tjänstens huvudnamn

Med rolltilldelningen som skapats i Azure lagrar du nu dina ACR-autentiseringsuppgifter i ett Jenkins-autentiseringsobjekt. Dessa autentiseringsuppgifter refereras under Jenkins-byggjobbet.

Tillbaka till vänster i Jenkins-portalen väljer du Hantera Jenkins-hanteraautentiseringsuppgifter Jenkins StoreGlobala autentiseringsuppgifter (obegränsad) Läggtill autentiseringsuppgifter

Kontrollera att typen av autentiseringsuppgifter är Användarnamn med lösenord och ange följande objekt:

• Användarnamn – appId för tjänstens huvudnamn som skapats för autentisering med ditt ACR-register.
• Lösenord – Lösenordet för tjänstens huvudnamn som skapats för autentisering med ditt ACR-register.
• ID – Autentiseringsidentifierare, till exempel acr-credentials

När du är klar ser formuläret för autentiseringsuppgifter ut som i följande exempel:

Välj OK och återgå till Jenkins-portalen.

Skapa ett Jenkins-projekt

På jenkins-portalens startsida väljer du Nytt objekt till vänster:

1. Ange azure-vote som jobbnamn. Välj Freestyle-projektoch sedan OK

2. Under avsnittet Allmänt väljer du GitHub projekt och anger url:en för din fördelade lagringsplatsen, till exempel ditt-github-konto /azure-voting-app-redis

3. I avsnittet Källkodshantering väljer du Git,anger url:en för din fördelade lagringsplatsen, till exempel ditt-github-konto /azure-voting-app-redis.git

4. I avsnittet Build Triggers (Skapa utlösare) väljer GitHub hook trigger for GITscm polling (Hook-utlösare för GITscm-avsökning)

5. Under Build Environment (Byggmiljö)väljer du Use secret texts or files (Använd hemliga texter eller filer)

6. Under Bindningarväljer du Lägg tillanvändarnamn och lösenord (avgränsade)

   • Ange ACR_ID för ACR_IDoch ACR_PASSWORD för ACR_PASSWORD

     

7. Välj att lägga till build-stegetav typen Execute shell och använd följande text. Det här skriptet skapar en ny containeravbildning och push-erar den till ditt ACR-register.

   # 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. Lägg till ytterligare ett build-stegav typen Execute shell och använd följande text. Det här skriptet uppdaterar programdistributionen i AKS med den nya containeravbildningen från ACR.

   # 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. När du är klar klickar du på Spara.

Testa Jenkins-versionen

Innan du automatiserar jobbet baserat på GitHub måste du testa Jenkins-versionen manuellt.

Den här versionen verifierar att jobbet har konfigurerats korrekt. Den bekräftar att rätt Kubernetes-autentiseringsfil är på plats och att autentiseringen till ACR fungerar.

På den vänstra menyn i projektet väljer du Skapa nu.

Den första versionen längre när Docker-avbildningsskikten hämtas till Jenkins-servern.

Byggena utför följande uppgifter:

1. Klonar GitHub lagringsplats
2. Skapar en ny containeravbildning
3. Push-pushar containeravbildningen till ACR-registret
4. Uppdaterar avbildningen som används av AKS-distributionen

Eftersom inga ändringar har gjorts i programkoden är webbgränssnittet oförändrat.

När byggjobbet är klart väljer du version 1 under bygghistoriken. Välj Konsolutdata och visa utdata från byggprocessen. Den sista raden bör visa att bygget har lyckats.

Skapa en GitHub webhook

Nu när en lyckad manuell version är klar integrerar GitHub i Jenkins-versionen. Använd en webhook för att köra Jenkins-byggjobbet varje gång koden har GitHub.

Skapa en GitHub webhook genom att utföra följande steg:

1. Bläddra till din GitHub lagringsplats i en webbläsare.

2. Välj Inställningar och sedan Webhooks på vänster sida.

3. Välj lägg till webhook. Som Nyttolast-URLanger du , där är <publicIp> IP-adressen för Jenkins-servern. Se till att inkludera den avslutande / . Lämna övriga standardvärden för innehållstyp och utlösare för push-händelser.

4. Välj Lägg till webhook.

   

Testa den fullständiga CI/CD-pipelinen

Nu kan du testa hela CI/CD-pipelinen. När du push-arar en GitHub sker följande steg:

1. Den GitHub webhooken meddelar Jenkins.
2. Jenkins startar byggjobbet och hämtar den senaste kod commit från GitHub.
3. En Docker-version startas med hjälp av den uppdaterade koden och den nya containeravbildningen taggas med det senaste build-numret.
4. Den här nya containeravbildningen push-skickas till Azure Container Registry.
5. Programmet som körs på Azure Kubernetes Service uppdateras med den senaste avbildningen från Azure Container Registry.

Öppna det klonade programmet med en kodredigerare på utvecklingsdatorn. Under katalogen /azure-vote/azure-vote öppnar du filen med namnet config_file.cfg. Uppdatera röstvärdena i den här filen till något annat än katter och hundar, som du ser i följande exempel:

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

När den har uppdaterats sparar du filen, sparar ändringarna och push-loggarna till din GitHub lagringsplats. Den GitHub webhooken utlöser ett nytt byggjobb i Jenkins. Övervaka byggprocessen på Jenkins-webbinstrumentpanelen. Det tar några sekunder att hämta den senaste koden, skapa och skicka den uppdaterade avbildningen och distribuera det uppdaterade programmet i AKS.

När bygget är klart uppdaterar du webbläsaren för Azure Vote-exempelprogrammet. Ändringarna visas, som du ser i följande exempel:

Nästa steg