Oktatóanyag: Jenkins-folyamat létrehozása a GitHub és a Docker használatával

Cikk
06/08/2023

Fontos

Számos Azure-szolgáltatás rendelkezik Jenkins beépülő modulokkal. Ezen beépülő modulok némelyike 2024. február 29-étől nem támogatott. A Jenkins azure-szolgáltatásokkal való integrálásának jelenleg az Azure CLI az ajánlott módja. További információ: Jenkins beépülő modulok az Azure-hoz.

Az alkalmazás fejlesztésének létrehozási és tesztelési fázisának automatizálásához használhat egy folyamatos integrációs és fejlesztési (CI/CD) folyamatot. Ebben az oktatóanyagban létrehozhat egy CI/CD folyamatot egy Azure-beli virtuális gépen, továbbá megismerkedhet a következőkkel is:

Jenkins virtuális gép létrehozása
A Jenkins telepítése és konfigurálása
Webhook-integráció létrehozása a Github és a Jenkins között
Jenkins buildfeladatok létrehozása és aktiválása a GitHub-véglegesítésekből
Docker-rendszerkép létrehozása az alkalmazáshoz
Annak ellenőrzése, hogy a GitHub-véglegesítések új Docker-rendszerképet hoznak létre és frissítik a futó alkalmazást

Ez az oktatóanyag az Azure Cloud Shell parancssori felületét használja, amely folyamatosan frissül a legújabb verzióra. A Cloud Shell megnyitásához válassza a Kipróbálás lehetőséget bármely kódblokk tetején.

Ha a parancssori felület helyi telepítését és használatát választja, akkor ehhez az oktatóanyaghoz az Azure CLI 2.0.30-as vagy újabb verziójára lesz szükség. 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.

Jenkins-példány létrehozása

A Linux virtuális gép testre szabása az első rendszerbetöltéskor című korábbi oktatóanyagból megtudhatta, hogyan automatizálható egy virtuális gép testreszabása a cloud-init használatával. Ez az oktatóanyag egy cloud-init-fájlt használ a Jenkins és a Docker egy virtuális gépre való telepítéséhez. A Jenkins egy népszerű, nyílt forráskódú automatizáló kiszolgáló, amely zökkenőmentesen integrálható az Azure-ral a folyamatos integráció (CI) és a folyamatos továbbítás (CD) érdekében. A Jenkins további oktatóanyagait itt találja: Jenkins az Azure-központban.

Az aktuális felületen hozzon létre egy cloud-init-jenkins.txt nevű fájlt, és illessze bele a következő konfigurációt. Például hozza létre a fájlt a Cloud Shellben, és ne a helyi gépén. Írja be a sensible-editor cloud-init-jenkins.txt parancsot a fájl létrehozásához és az elérhető szerkesztők listájának megtekintéséhez. Ügyeljen arra, hogy megfelelően másolja ki a teljes cloud-init-fájlt, különösen az első sort:

#cloud-config
package_upgrade: true
write_files:
  - path: /etc/systemd/system/docker.service.d/docker.conf
    content: |
      [Service]
        ExecStart=
        ExecStart=/usr/bin/dockerd
  - path: /etc/docker/daemon.json
    content: |
      {
        "hosts": ["fd://","tcp://127.0.0.1:2375"]
      }
runcmd:
  - apt install openjdk-8-jre-headless -y
  - wget -q -O - https://pkg.jenkins.io/debian/jenkins-ci.org.key | sudo apt-key add -
  - sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
  - apt-get update && apt-get install jenkins -y
  - curl -sSL https://get.docker.com/ | sh
  - usermod -aG docker azureuser
  - usermod -aG docker jenkins
  - service jenkins restart

Mielőtt létrehozhatna egy virtuális gépet, létre kell hoznia egy erőforráscsoportot az az group create paranccsal. A következő példában létrehozunk egy myResourceGroupJenkins nevű erőforráscsoportot az eastus helyen:

az group create --name myResourceGroupJenkins --location eastus

Most hozzon létre egy virtuális gépet az az vm create paranccsal. Használja a --custom-data paramétert a cloud-init konfigurációs fájl megadásához. Adja meg a cloud-init-jenkins.txt teljes elérési útját, ha az aktuális munkakönyvtáron kívülre mentette.

az vm create --resource-group myResourceGroupJenkins \
    --name myVM \
    --image UbuntuLTS \
    --admin-username azureuser \
    --generate-ssh-keys \
    --custom-data cloud-init-jenkins.txt

A virtuális gép létrehozása és konfigurálása néhány percig tart.

A virtuális gép felé irányuló webes forgalom engedélyezéséhez használja az az vm open-port parancsot a 8080-as port megnyitásához a Jenkins forgalma előtt, és az 1337-es port megnyitásához a Node.js-alkalmazás előtt, amelyet egy mintaalkalmazás futtatásához használunk:

az vm open-port --resource-group myResourceGroupJenkins --name myVM --port 8080 --priority 1001
az vm open-port --resource-group myResourceGroupJenkins --name myVM --port 1337 --priority 1002

A Jenkins konfigurálása

A Jenkins-példány eléréséhez kérje le a virtuális gép nyilvános IP-címét:

az vm show --resource-group myResourceGroupJenkins --name myVM -d --query [publicIps] --o tsv

Biztonsági okokból a Jenkins telepítésének megkezdéséhez meg kell adnia az eredeti rendszergazdai jelszót, amelyet egy szöveges fájl tartalmaz a virtuális gépen. Használja az előző lépésben lekért nyilvános IP-címet a virtuális gép SSH-n keresztül való eléréséhez:

ssh azureuser@<publicIps>

Ellenőrizze, hogy a Jenkins fut-e a service következő paranccsal:

$ service jenkins status
● jenkins.service - LSB: Start Jenkins at boot time
   Loaded: loaded (/etc/init.d/jenkins; generated)
   Active: active (exited) since Tue 2019-02-12 16:16:11 UTC; 55s ago
     Docs: man:systemd-sysv-generator(8)
    Tasks: 0 (limit: 4103)
   CGroup: /system.slice/jenkins.service

Feb 12 16:16:10 myVM systemd[1]: Starting LSB: Start Jenkins at boot time...
...

Tekintse meg a Jenkins-telepítéshez tartozó initialAdminPassword értéket és másolja a vágólapra:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Ha a fájl még nem elérhető, várjon néhány percet, hogy a cloud-init elkészülhessen a Jenkins és a Docker telepítésével.

Ezután indítson el egy webböngészőt és lépjen a http://<publicIps>:8080 webhelyre. Végezze el a Jenkins kezdeti beállítását az alábbiak szerint:

Válassza a Telepíteni kívánt beépülő modulok kiválasztása lehetőséget
Keressen a GitHub kifejezésre a fenti szövegmezőben. Jelölje be a GitHub jelölőnégyzetét, majd válassza az Install (Telepítés) lehetőséget.
Hozza létre az első rendszergazdai felhasználót. Írjon be egy felhasználónevet, például admin, majd adja meg a saját biztonságos jelszavát. Végül gépelje be teljes nevét és e-mail-címét.
Válassza a Save and Finish (Mentés és befejezés) elemet
Amint Jenkins készen áll, kattintson a Start using Jenkins (Jenkins használatának megkezdése) elemre
- Ha a webböngésző Jenkins használatának megkezdésekor egy üres lapot jelenít meg, indítsa újra a Jenkins szolgáltatást. Az SSH-munkamenetben gépelje be a sudo service jenkins restart parancsot, majd frissítse a webböngészőt.
Szükség esetén jelentkezzen be a Jenkinsbe a létrehozott felhasználónévvel és jelszóval.

GitHub-webhook létrehozása

A GitHubbal való integráció konfigurálásához nyissa meg a Node.js „Helló világ” mintaalkalmazást az Azure-példatárból. 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.

Hozzon létre egy webhookot a létrehozott elágazásban:

Válassza a Gépház, majd a bal oldali Webhookok lehetőséget.
Válassza a Webhook hozzáadása lehetőséget, majd írja be a Jenkinst a szűrőmezőbe.
A Payload URL-címhez írja be a következőthttp://<publicIps>:8080/github-webhook/: . Ügyeljen rá, hogy az URL-címből ne maradjon le a „/” záró karakter.
Tartalomtípus esetén válassza az application/x-www-form-urlencoded lehetőséget.
Melyik esemény esetén szeretné aktiválni ezt a webhookot?, válassza a Csak a leküldéses esemény lehetőséget.
Jelölje be az Aktív értéket.
Kattintson a Webhook hozzáadása elemre.

Add GitHub webhook to your forked repo

Jenkins-feladat létrehozása

Ahhoz, hogy a Jenkins válaszoljon a GitHub eseményeire, például egy kód véglegesítésére, hozzon létre egy Jenkins-feladatot. Az URL-ek használata a saját GitHub-elágazásokhoz.

A Jenkins webhely kezdőlapján válassza a Create new jobs (Új feladatok létrehozása) lehetőséget.

A feladatnak adja a HelloWorld nevet. Válassza a Freestyle project (Szabad stílusú projekt) lehetőséget, majd kattintson az OK gombra.
A General (Általános) szakaszban válassza ki a GitHub project (GitHub-projekt) lehetőséget, majd adja meg az elágaztatott adattár URL-címét, például: https://github.com/cynthn/nodejs-docs-hello-world
A Source code management (Forráskódkezelés) szakaszban válassza a Git elemet, majd adja meg az elágaztatott .git-adattár URL-címét, például: https://github.com/cynthn/nodejs-docs-hello-world.git
A Build Triggers (Eseményindítók létrehozása) szakaszban válassza a GitHub hook trigger for GITScm polling (GitHub beavatkozási pont eseményindító GITScm lekérdezés esetén) lehetőséget.
A Build (Létrehozás) szakaszban válassza az Add build step (Létrehozási lépés hozzáadása) lehetőséget. Válassza az Execute shell (Felület futtatása) lehetőséget, majd a parancssori ablakba írja be a következőt: echo "Test".
Kattintson a feladatablak alján található Save (Mentés) gombra.

GitHub-integráció tesztelése

A GitHub és a Jenkins integrációjának teszteléséhez véglegesítsen egy változtatást az elágazásban.

Lépjen vissza a GitHub webes kezelőfelületére, válassza ki az elágaztatott adattárat, majd válassza ki az index.js fájlt. A ceruza ikonra kattintva szerkessze a fájlt. A hatodik sor legyen a következő:

response.end("Hello World!");

A módosítások véglegesítéséhez kattintson az alul lévő Commit changes (Módosítások véglegesítése) gombra.

A Jenkinsben elindul egy új létrehozás a feladatoldal bal alsó sarkában található Build history (Létrehozási előzmények) szakaszban. Válassza ki a létrehozás számának hivatkozását, majd válassza a bal oldali Console output (Konzolkimenet) lehetőséget. Megtekintheti a Jenkins által végrehajtott lépéseket, ahogy az lehívja a kódot a GitHubról, a létrehozási művelet pedig a következő üzenetet jeleníti meg a konzolon: Test. A GitHubon végzett minden egyes véglegesítéskor a webhook kapcsolatba lép a Jenkinsszel és aktivál egy új létrehozást.

Docker-létrehozási rendszerkép definiálása

A GitHub-véglegesítéseken alapuló Node.js-alkalmazás futásának megtekintéséhez hozzunk létre egy Docker-rendszerképet az alkalmazás futtatásához. A rendszerkép egy Docker-fájlból jön létre, amely meghatározza, hogy az alkalmazást futtató tárolót hogyan kell konfigurálni.

A virtuális géphez vezető SSH-kapcsolaton keresztül váltson át a Jenkins-munkaterület könyvtárára, amely az előző lépésben létrehozott feladat nevét viseli. Ebben a példában a neve HelloWorld.

cd /var/lib/jenkins/workspace/HelloWorld

Hozzon létre egy fájlt ebben a munkaterület-könyvtárban a sudo sensible-editor Dockerfile használatával, és másolja bele a következő tartalmakat. Ügyeljen arra, hogy megfelelően másolja ki a teljes Docker-fájlt, különösen az első sort:

FROM node:alpine

EXPOSE 1337

WORKDIR /var/www
COPY package.json /var/www/
RUN npm install
COPY index.js /var/www/

A Docker-fájl az alap Node.js-rendszerképet használja az Alpine Linux használatával, megnyitja az 1337-es portot, amelyen a Hello World alkalmazás fut, majd másolja az alkalmazás fájljait, és végül inicializálja az alkalmazást.

Jenkins létrehozási szabályok létrehozása

Az előző lépésben létrehoztunk egy alapszintű Jenkins létrehozási szabályt, amely egy üzenetet jelenített meg a konzolon. Hozzuk létre azt a lépést, amely a Docker-fájlunk használatával futtatja az alkalmazást.

A Jenkins-példányba visszalépve válassza ki az előző lépésben létrehozott feladatot. Válassza a Configure (Konfigurálás) lehetőséget a bal oldalon, majd görgessen le a Build (Létrehozás) szakaszig:

Távolítsa el a meglévő echo "Test" létrehozási lépést. Kattintson a meglévő létrehozási lépés mezőjének jobb felső sarkában található vörös keresztre.
Válassza az Add build step (Létrehozási lépés hozzáadása), majd az Execute shell (Felület futtatása) lehetőséget.

A Command (Parancs) mezőbe írja be az alábbi Docker-parancsokat, majd kattintson a Save (Mentés) gombra:

docker build --tag helloworld:$BUILD_NUMBER .
docker stop helloworld && docker rm helloworld
docker run --name helloworld -p 1337:1337 helloworld:$BUILD_NUMBER node /var/www/index.js &

A Docker-létrehozási lépések létrehoznak egy rendszerképet, és felcímkézik azt a Jenkins verziószámával, hogy nyomon lehessen követni a rendszerképek előzményeit. A rendszer az alkalmazást futtató meglévő tárolókat leállítja és eltávolítja. Ezután elindul egy új tároló, amely a rendszerképet használja és a GitHub legújabb véglegesítésein alapuló Node.js-alkalmazást futtatja.

A folyamat tesztelése

A teljes folyamat működésének megtekintéséhez szerkessze ismét az elágaztatott GitHub-adattárban található index.js fájlt, majd válassza a Commit change (Módosítás véglegesítése) lehetőséget. A Jenkinsben elindul egy új feladat a GitHub webhookja alapján. A rendszer néhány másodperc alatt létrehozza a Docker-rendszerképet és elindítja az alkalmazást egy új tárolóban.

Szükség esetén kérje le újra a virtuális gép nyilvános IP-címét:

az vm show --resource-group myResourceGroupJenkins --name myVM -d --query [publicIps] --o tsv

Nyisson meg egy webböngészőt, majd írja be a következőt: http://<publicIps>:1337. Megjelenik a Node.js-alkalmazás, amely az alábbiak szerint tükrözi a legújabb GitHub-véglegesítéseket:

Running Node.js app

Most szerkessze újra az index.js fájlt a GitHubban, majd véglegesítse a módosítást. Várjon néhány másodpercet, amíg a Jenkins elvégzi a feladatot, majd frissítse a böngészőt, hogy az alkalmazás új verzióját lássa, amely egy új tárolóban fut:

Running Node.js app after another GitHub commit

További lépések

Ebben az oktatóanyagban úgy konfiguráltuk a GitHubot, hogy minden egyes kódvéglegesítéskor futtasson egy Jenkins létrehozási feladatot, majd helyezzen üzembe egy Docker-tárolót az alkalmazás teszteléséhez. Megtanulta végrehajtani az alábbi műveleteket:

Jenkins virtuális gép létrehozása
A Jenkins telepítése és konfigurálása
Webhook-integráció létrehozása a Github és a Jenkins között
Jenkins buildfeladatok létrehozása és aktiválása a GitHub-véglegesítésekből
Docker-rendszerkép létrehozása az alkalmazáshoz
Annak ellenőrzése, hogy a GitHub-véglegesítések új Docker-rendszerképet hoznak létre és frissítik a futó alkalmazást

A következő oktatóanyag azt mutatja be, hogyan integrálható a Jenkins és az Azure DevOps Services.

Alkalmazások üzembe helyezése a Jenkins és az Azure DevOps Services használatával