Oktatóanyag: Üzembe helyezés a GitHubról az Azure Kubernetes Service-be a Jenkins használatával

Ez az oktatóanyag üzembe helyez egy mintaalkalmazást a GitHubról egy Azure Kubernetes Service-fürtön a Folyamatos integráció (CI) és a folyamatos üzembe helyezés (CD) jenkinsbeli beállításával.

Ebben az oktatóanyagban a következő feladatokat fogja elvégezni:

Előfeltételek

Az oktatóanyag elvégzéséhez az alábbi elemekre van szüksége:

• A Kubernetes, a Git, a CI/CD és a tárolórendszerképek alapszintű ismerete

• Egy AKS-fürt , amely kubectl az AKS-fürt hitelesítő adataival van konfigurálva.

• Egy Azure Container Registry (ACR) beállításjegyzék, az ACR bejelentkezési kiszolgáló neve és az AKS-fürt, amely az ACR-beállításjegyzékkel való hitelesítésre van konfigurálva.

• Egy Azure-beli virtuális gépen üzembe helyezett Jenkins-vezérlő .

• Az Azure CLI 2.0.46-os vagy újabb verziója telepítve és konfigurálva van. A verzió azonosításához futtassa a következőt: az --version. Ha telepíteni vagy frissíteni szeretne: Az Azure CLI telepítése.

• A Docker telepítve van a fejlesztői rendszeren

• A fejlesztői rendszerre telepített GitHub-fiók, a Személyes GitHub-hozzáférési jogkivonat és a Git-ügyfél

• Ha a Jenkins üzembe helyezésének ez a példaszkriptje helyett saját Jenkins-példányt ad meg, a Jenkins-példánynak telepítenie és konfigurálnia kell a Dockert és a kubectl-et.

Az alkalmazás előkészítése

Ebben a cikkben egy azure-beli mintaalkalmazást használ, amely egy webes felületet és egy Redist tartalmaz az ideiglenes adattároláshoz.

Mielőtt integrálja a Jenkinst és az AKS-t az automatizált üzembe helyezéshez, először manuálisan készítse elő és telepítse az Azure-szavazóalkalmazást az AKS-fürtön. Ez a manuális üzembe helyezés lehetővé teszi az alkalmazás működés közbeni megjelenítését.

Fork a következő GitHub-adattárat a mintaalkalmazáshoz : https://github.com/Azure-Samples/azure-voting-app-redis. Ahhoz, hogy elágaztassa a példatárt a saját GitHub-fiókja felé, kattintson a Fork (Elágaztatás) gombra a jobb felső sarokban.

Klónozza az elágazást a fejlesztői rendszerbe. Győződjön meg arról, hogy az elágaztatás URL-címét használja az adattár klónozásakor:

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

Váltson a klónozott elágazás könyvtárára:

cd azure-voting-app-redis

A mintaalkalmazáshoz szükséges tárolórendszerképek létrehozásához használja a docker-compose.yaml fájlt a következőveldocker-compose:

docker-compose up -d

A szükséges alaplemezképek lekérése és az alkalmazástárolók létrehozása. Ezután a Docker-rendszerképek paranccsal megtekintheti a létrehozott lemezképet. Három rendszerkép lett letöltve vagy jött létre. Az azure-vote-front rendszerkép tartalmazza az alkalmazást, és a nginx-flask rendszerképet használja alapként. A redis rendszerkép egy Redis-példány indítására szolgál:

$ 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

Jelentkezzen be az Azure Container Registrybe.

az acr login -n <acrLoginServer>

Cserélje le <acrLoginServer> az ACR bejelentkezési kiszolgálóra.

A docker-címke paranccsal címkézze meg a rendszerképet az ACR bejelentkezési kiszolgáló nevével és a verziószámmalv1. Használja az előző lépésben beszerzett saját <acrLoginServer> nevét:

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

Végül küldje el az azure-vote-front rendszerképet az ACR-beállításjegyzékbe. Cserélje le <acrLoginServer> ismét a saját ACR-beállításjegyzék bejelentkezési kiszolgálójának nevét, például myacrregistry.azurecr.io:

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

A mintaalkalmazás üzembe helyezése az AKS-ben

A mintaalkalmazás AKS-fürtön való üzembe helyezéséhez használhatja a Kubernetes-jegyzékfájlt az Azure-beli szavazási adattár adattárának gyökerében. Nyissa meg a azure-vote-all-in-one-redis.yaml jegyzékfájlt egy olyan szerkesztővel, mint a vi. Az microsoft helyére az ACR bejelentkezési kiszolgálójának nevét írja be. Ez az érték a jegyzékfájl 60. sorában található:

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

Ezután a kubectl apply paranccsal helyezze üzembe az alkalmazást az AKS-fürtben:

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

Létrejön egy Kubernetes terheléselosztó szolgáltatás, amely az alkalmazást az interneten teszi elérhetővé. Ez a folyamat eltarthat néhány percig. A terheléselosztó üzembe helyezésének előrehaladásának figyeléséhez használja a kubectl get service parancsot az --watch argumentummal. Miután az EXTERNAL-IP cím pending állapotról egy IP-címre változik, a Control + C billentyűparanccsal állítsa le a kubectl figyelési folyamatát.

$ 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

Az alkalmazás működés közbeni megtekintéséhez nyisson meg egy webböngészőt a szolgáltatás külső IP-címére. Megjelenik az Azure-beli szavazási alkalmazás, ahogyan az a következő példában is látható:

Jenkins-vezérlő konfigurálása

Alkalmazza a következő módosításokat az AKS-környezetek Jenkins-vezérlőből való engedélyezéséhez:

Bejövő port 80 megnyitása.

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

Cserélje le és <Jenkins_Controller_VM> cserélje le <Resource_Group_name> a megfelelő értékeket.

SSH a Jenkins-vezérlőbe

ssh azureuser@<PublicIPAddres>

Cserélje le <PublicIPAddress> a Jenkins-vezérlő IP-címére.

> Bejelentkezés az AzCLI-be

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

az login

A Docker telepítése

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;

A Kubectl és Csatlakozás telepítése az AKS-be

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

Cserélje le és <AKS_Name> cserélje le <Resource_Group> a megfelelő értékeket.

Hozzáférés konfigurálása

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

Jenkins környezeti változó létrehozása

Az ACR bejelentkezési kiszolgáló nevének tárolására jenkins környezeti változót használunk. Erre a változóra a Jenkins buildelési feladata során hivatkozunk. A környezeti változó létrehozásához hajtsa végre a következő lépéseket:

• A Jenkins portál bal oldalán válassza a Jenkins-konfigurálási>rendszer kezelése lehetőséget

• A Globális tulajdonságok csoportban válassza a Környezeti változók lehetőséget. Adjon hozzá egy változót az ACR bejelentkezési kiszolgáló nevével ACR_LOGINSERVER és értékével.

  

• Ha elkészült, válassza a Lap alján található Mentés lehetőséget.

Jenkins-hitelesítő adatok létrehozása az ACR-hez

A CI/CD folyamat során a Jenkins új tárolólemezképeket hoz létre az alkalmazásfrissítések alapján, majd le kell küldenie ezeket a lemezképeket az ACR-beállításjegyzékbe.

Ahhoz, hogy a Jenkins leküldhesse a frissített tárolólemezképeket az ACR-be, meg kell adnia az ACR hitelesítő adatait.

A szerepkörök és engedélyek elkülönítéséhez konfiguráljon egy szolgáltatásnevet a Jenkinshez közreműködői engedélyekkel az ACR-beállításjegyzékben.

Szolgáltatásnév létrehozása a Jenkins számára az ACR használatához

Először hozzon létre egy egyszerű szolgáltatást az az ad sp create-for-rbac paranccsal:

az ad sp create-for-rbac

Ez a parancs az alábbi példához hasonló kimenetet hoz létre:

{
  "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>"
}

Jegyezze fel az appID és a password értékét. Ezek az értékek a következő lépésekben használhatók a hitelesítőadat-erőforrás Jenkinsben való konfigurálásához.

Kérje le az ACR-beállításjegyzék erőforrás-azonosítóját az az acr show paranccsal, és tárolja változóként.

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

Cserélje le és <acrLoginServer> cserélje le <Resource_Group> a megfelelő értékeket.

Hozzon létre egy szerepkör-hozzárendelést a szolgáltatásnév közreműködői jogosultságainak az ACR-beállításjegyzékhez való hozzárendeléséhez.

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

Cserélje le <appId> a szolgáltatásnév létrehozásához használt perverz parancs kimenetében megadott értékre.

Hitelesítő erőforrás létrehozása a Jenkinsben az ACR szolgáltatásnévhez

Az Azure-ban létrehozott szerepkör-hozzárendeléssel most az ACR hitelesítő adatait egy Jenkins hitelesítő objektumban tárolhatja. Ezekre a hitelesítő adatokra a Jenkins buildelési feladata során hivatkozunk.

A Jenkins portál bal oldalán válassza a Jenkins manage Credentials Jenkins Store>global credentials (unrestricted)Add Credentials (Credentials) (Unrestricted)>Add Credentials (Credentials) (A Jenkins>store globális hitelesítő adatainak>kezelése) lehetőséget.

Győződjön meg arról, hogy a hitelesítő adatok típusa felhasználónév jelszóval , és adja meg a következő elemeket:

• Felhasználónév – Az ACR-beállításjegyzékkel való hitelesítéshez létrehozott szolgáltatásnév appId azonosítója .
• Jelszó – Az ACR-beállításjegyzékkel való hitelesítéshez létrehozott szolgáltatásnév jelszava .
• ID – Hitelesítő azonosító, például acr-credentials

Ha elkészült, a hitelesítő adatok űrlapja a következő példához hasonlóan néz ki:

Válassza az OK gombot, és térjen vissza a Jenkins portálra.

Jenkins-projekt létrehozása

A Jenkins portál kezdőlapján válassza az Új elem lehetőséget a bal oldalon:

1. Adja meg az azure-vote nevet feladatnévként. Válassza a Freestyle projektet, majd az OK gombot

2. Az Általános szakaszban válassza a GitHub-projektet, és adja meg az elágaztatott adattár URL-címét, például https://github.com/<a saját github-account>/azure-voting-app-redis

3. A Forráskód kezelése szakaszban válassza a Git lehetőséget, adja meg az elágaztatott adattár .git URL-címét, például https://github.com/<a saját github-account>/azure-voting-app-redis.git

4. Az Eseményindítók összeállítása szakaszban válassza a GitHub-kampó eseményindítót a GITscm-lekérdezéshez

5. A Build Environment területen válassza a Titkos szövegek vagy fájlok használata lehetőséget

6. A Kötések csoportban válassza a Felhasználónév és jelszó hozzáadása>(külön) lehetőséget

   • Adja meg ACR_ID a felhasználónév változót és ACR_PASSWORD a jelszóváltozót

     

7. Adja hozzá az Execute shell típusú buildelési lépést, és használja az alábbi szöveget. Ez a szkript létrehoz egy új tárolórendszerképet, és leküldi azt az ACR-beállításjegyzékbe.

   # 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. Adjon hozzá egy másik, Execute shell típusú buildelési lépést, és használja a következő szöveget. Ez a szkript frissíti az alkalmazás üzembe helyezését az AKS-ben az ACR új tárolólemezképével.

   # 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. Ha végzett, kattintson a Mentés gombra.

A Jenkins build tesztelése

Mielőtt a GitHub-véglegesítések alapján automatizálja a feladatot, manuálisan tesztelje a Jenkins-buildet.

Ez a build ellenőrzi, hogy a feladat megfelelően lett-e konfigurálva. Megerősíti, hogy a megfelelő Kubernetes-hitelesítési fájl működik, és hogy az ACR-hitelesítés működik.

A projekt bal oldali menüjében válassza a Build Now lehetőséget.

Az első build tovább tart, amikor a Docker-rendszerképrétegek le lesznek húzva a Jenkins-kiszolgálóra.

A buildek a következő feladatokat hajtják végre:

1. Klónozza a GitHub-adattárat
2. Új tárolórendszerkép létrehozása
3. A tároló lemezképének leküldése az ACR-beállításjegyzékbe
4. Frissítések az AKS-üzembe helyezés által használt rendszerképet

Mivel az alkalmazáskódon nem történt módosítás, a webes felhasználói felület nem változik.

A buildelési feladat befejezése után válassza az 1 . buildet a buildelőzmények alatt. Válassza a Konzolkimenet lehetőséget , és tekintse meg a kimenetet a buildelési folyamatból. A végső sornak sikeres buildet kell jeleznie.

GitHub-webhook létrehozása

A sikeres manuális buildelés befejezése után integrálja a GitHubot a Jenkins-buildbe. Webhook használatával futtathatja a Jenkins buildelési feladatát minden alkalommal, amikor a kód le van kötelezve a GitHubra.

A GitHub webhook létrehozásához hajtsa végre a következő lépéseket:

1. Tallózással keresse meg az elágaztatott GitHub-adattárat egy webböngészőben.

2. Válassza a Gépház, majd a bal oldali Webhookok lehetőséget.

3. Válassza a Webhook hozzáadása lehetőséget. A Payload URL-címhez írja behttp://<publicIp:8080>/github-webhook/, hogy hol <publicIp> található a Jenkins-kiszolgáló IP-címe. Ügyeljen arra, hogy a záró elemet /is tartalmazza. Hagyja meg a tartalomtípus többi alapértelmezett beállítását, és aktiválja a leküldéses eseményeket.

4. Válassza a Webhook hozzáadása lehetőséget.

   

A teljes CI/CD-folyamat tesztelése

Most már tesztelheti a teljes CI/CD-folyamatot. Amikor leküld egy kód véglegesítést a GitHubra, a következő lépések történnek:

1. A GitHub webhook értesíti a Jenkinst.
2. A Jenkins elindítja a buildelési feladatot, és lekéri a legújabb kód véglegesítését a GitHubról.
3. A Docker-buildek a frissített kód használatával indulnak el, és az új tárolórendszerkép a legújabb buildszámmal van megjelölve.
4. Ezt az új tárolórendszerképet a rendszer leküldi az Azure Container Registrybe.
5. Az Azure Kubernetes Service-ben futó alkalmazás az Azure Container Registry legújabb rendszerképével frissül.

A fejlesztői gépen nyissa meg a klónozott alkalmazást egy kódszerkesztővel. Az /azure-vote/azure-vote könyvtárban nyissa meg a config_file.cfg nevű fájlt. Frissítse a fájlban szereplő szavazati értékeket a macskákon és kutyákon kívül másra, ahogy az a következő példában is látható:

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

Frissítéskor mentse a fájlt, véglegesítse a módosításokat, és küldje el őket a GitHub-adattár elágaztatásába. A GitHub webhook új buildelési feladatot indít el a Jenkinsben. A Jenkins webes irányítópultján figyelje a buildelési folyamatot. Néhány másodpercet vesz igénybe a legújabb kód lekérése, a frissített rendszerkép létrehozása és leküldése, valamint a frissített alkalmazás üzembe helyezése az AKS-ben.

A build befejezése után frissítse a webböngészőt a minta Azure-beli szavazási alkalmazásról. A módosítások az alábbi példában látható módon jelennek meg:

Következő lépések