Oktatóanyag: Üzembe helyezés Service Fabric-fürtön

Cikk
11/08/2023

Ez az oktatóanyag bemutatja a Jenkins-környezet beállításának számos lehetséges módját, valamint az alkalmazás Service Fabric-fürtön való üzembe helyezésének különböző módjait a létrehozás után. Kövesse az alábbi általános lépéseket a Jenkins sikeres konfigurálásához, a GitHub módosításainak lekéréséhez, az alkalmazás létrehozásához és a fürtben való üzembe helyezéséhez:

Győződjön meg arról, hogy telepíti az előfeltételeket.
Ezután kövesse az alábbi szakaszok lépéseit a Jenkins beállításához:
Miután beállította a Jenkinst, kövesse a Jenkins-feladat létrehozása és konfigurálása lépéseit a GitHub beállításához a Jenkins aktiválásához az alkalmazás módosításakor, valamint a Jenkins-feladat folyamatának konfigurálásához a buildelési lépéssel, hogy lekérje a módosításokat a GitHubról, és felépítse az alkalmazást.
Végül konfigurálja a Jenkins-feladat buildelés utáni lépését az alkalmazás Service Fabric-fürtben való üzembe helyezéséhez. A Jenkins kétféleképpen konfigurálható az alkalmazás fürtben való üzembe helyezésére:
- Fejlesztési és tesztelési környezetekhez használja az Üzembe helyezés konfigurálása fürtfelügyeleti végpont használatával című cikket. Ez a legegyszerűbb üzembe helyezési módszer.
- Éles környezetekben használja az Üzembe helyezés konfigurálása Azure-beli hitelesítő adatokkal. A Microsoft ezt a módszert éles környezetekhez javasolja, mert az Azure-beli hitelesítő adatokkal korlátozhatja a Jenkins-feladatok hozzáférését az Azure-erőforrásokhoz.

Előfeltételek

Győződjön meg arról, hogy a Git helyileg van telepítve. Az operációs rendszer alapján a Git letöltési oldaláról telepítheti a megfelelő Git-verziót. Ha még csak most ismerkedik a Git-dzsel, a Git dokumentációjából tudhat meg többet.
Ez a cikk a Service Fabric Első lépések mintáját használja a GitHubon: https://github.com/Azure-Samples/service-fabric-java-getting-started az alkalmazás létrehozásához és üzembe helyezéséhez. Ezt az adattárat követve elágaztathatja, vagy az utasítások némi módosításával használhatja a saját GitHub-projektet.

Service Fabric beépülő modul telepítése meglévő Jenkins-környezetben

Ha a Service Fabric beépülő modult egy meglévő Jenkins-környezethez adja hozzá, a következő lépéseket kell végrehajtania:

Service Fabric CLI (sfctl). Telepítse a parancssori felületet a rendszer szintjén a felhasználói szint helyett, így a Jenkins parancssori felületi parancsokat futtathat.
Java-alkalmazások telepítéséhez telepítse a Gradle-t és az Open JDK 8.0-t is.
A .NET Core 2.0-alkalmazások telepítéséhez telepítse a .NET Core 2.0 SDK-t.

Miután telepítette a környezethez szükséges előfeltételeket, megkeresheti az Azure Service Fabric beépülő modult a Jenkins piactéren, és telepítheti azt.

Miután telepítette a beépülő modult, ugorjon tovább a Jenkins-feladat létrehozásához és konfigurálásához.

A Jenkins beállítása egy Service Fabric-fürtben

A Jenkinst egy Service Fabric-fürtben vagy azon kívül is beállíthatja. Az alábbi szakaszok bemutatják, hogyan állíthatja be a fürtön belül, miközben Azure Storage-fiókot használ a tárolópéldány állapotának mentéséhez.

Győződjön meg arról, hogy telepítve van egy Service Fabric Linux-fürt, amelyen telepítve van a Docker. Az Azure-ban futó Service Fabric-fürtökre már telepítve van a Docker. Ha helyileg futtatja a fürtöt (OneBox fejlesztői környezet), ellenőrizze, hogy a Docker telepítve van-e a számítógépen a docker info paranccsal. Ha nincs telepítve, telepítse a következő parancsokkal:
```
sudo apt-get install wget
wget -qO- https://get.docker.io/ | sh
```
Feljegyzés

Győződjön meg arról, hogy a 8081-port egyéni végpontként van megadva a fürtben. Ha helyi fürtöt használ, győződjön meg arról, hogy a 8081-s port nyitva van a gazdagépen, és hogy nyilvános IP-címmel rendelkezik.

Klónozza az alkalmazást az alábbi parancsokkal:

git clone https://github.com/suhuruli/jenkins-container-application.git
cd jenkins-container-application

A Jenkins-tároló állapotának megőrzése fájlmegosztásban:
1. Hozzon létre egy Azure-tárfiókot a fürttel azonos régióban egy olyan névvel, mint a sfjenkinsstorage1.
2. Hozzon létre egy fájlmegosztást a tárfiók alatt egy olyan névvel, mint a sfjenkins.
3. Kattintson a Csatlakozás a fájlmegosztáshoz, és jegyezze fel a linuxos Csatlakozás alatt megjelenített értékeket, az értéknek az alábbihoz hasonlóan kell kinéznie:
```
sudo mount -t cifs //sfjenkinsstorage1.file.core.windows.net/sfjenkins [mount point] -o vers=3.0,username=<username>,password=<storage-key>,dir_mode=0777,file_mode=0777
```
Feljegyzés

A cifs-megosztások csatlakoztatásához telepítenie kell a cifs-utils csomagot a fürtcsomópontokon.
Frissítse a szkript helyőrző értékeit a setupentrypoint.sh 2. lépésben szereplő Azure-Storage-részletekkel.
```
vi JenkinsSF/JenkinsOnSF/Code/setupentrypoint.sh
```
- Cserélje le [REMOTE_FILE_SHARE_LOCATION] a fenti 2. lépésben a csatlakozás kimenetéből származó értékkel //sfjenkinsstorage1.file.core.windows.net/sfjenkins .
- Cserélje le [FILE_SHARE_CONNECT_OPTIONS_STRING] a fenti 2. lépésben szereplő értékre vers=3.0,username=<username>,password=<storage-key>,dir_mode=0777,file_mode=0777 .
Csak biztonságos fürt:

Az alkalmazások Biztonságos fürtön a Jenkinsből való üzembe helyezésének konfigurálásához a fürttanúsítványnak elérhetőnek kell lennie a Jenkins-tárolóban. A ApplicationManifest.xml fájlban a ContainerHostPolicies címke alatt adja hozzá ezt a tanúsítványhivatkozást, és frissítse az ujjlenyomat értékét a fürttanúsítványéval.
```
<CertificateRef Name="MyCert" X509FindValue="[Thumbprint]"/>
```
Ezenkívül adja hozzá a következő sorokat az ApplicationManifest (gyökér) címke alatt a ApplicationManifest.xml fájlban, és frissítse az ujjlenyomat értékét a fürttanúsítvány értékével.
```
<Certificates>
  <SecretsCertificate X509FindType="FindByThumbprint" X509FindValue="[Thumbprint]" />
</Certificates> 
```
Csatlakozás a fürthöz, és telepítse a tárolóalkalmazást.

Biztonságos fürt
```
sfctl cluster select --endpoint https://PublicIPorFQDN:19080  --pem [Pem] --no-verify # cluster connect command
bash Scripts/install.sh
```
Az előző parancs PEM formátumban veszi át a tanúsítványt. Ha a tanúsítvány PFX formátumban van, az alábbi paranccsal konvertálhatja azt. Ha a PFX-fájl nem jelszóval védett, adja meg a passin paramétert a következőként -passin pass:: .
```
openssl pkcs12 -in cert.pfx -out cert.pem -nodes -passin pass:<password>
```
Nem biztonságos fürt
```
sfctl cluster select --endpoint http://PublicIPorFQDN:19080 # cluster connect command
bash Scripts/install.sh
```
Ezzel telepít a fürtön egy Jenkins-tárolót, amely a Service Fabric Explorerrel figyelhető meg.

Feljegyzés

Eltarthat néhány percig, amíg a Jenkins-rendszerkép le lesz töltve a fürtre.
Nyissa meg a http://PublicIPorFQDN:8081 URL-címet a böngészőben. Így megkapja a bejelentkezéshez szükséges kezdeti rendszergazdai jelszó elérési útját.
Tekintse meg a Service Fabric Explorert annak megállapításához, hogy melyik csomóponton fut a Jenkins-tároló. A Secure Shell (SSH) bejelentkezik ebbe a csomópontba.
```
ssh user@PublicIPorFQDN -p [port]
```
Kérje le a tároló példányazonosítóját a docker ps -a paranccsal.
A Secure Shell (SSH) jelentkezzen be a tárolóba, és illessze be a Jenkins portálon megjelenített elérési utat. Ha például a portálon az elérési utat PATH_TO_INITIAL_ADMIN_PASSWORDjeleníti meg, futtassa a következő parancsokat:
```
docker exec -t -i [first-four-digits-of-container-ID] /bin/bash   # This takes you inside Docker shell
```
```
cat PATH_TO_INITIAL_ADMIN_PASSWORD # This displays the password value
```
A Jenkins Első lépések lapján válassza a Telepítéshez a Beépülő modul kiválasztása lehetőséget, jelölje be a Nincs jelölőnégyzetet, és kattintson a Telepítés gombra.
Hozzon létre egy felhasználót, vagy válassza a rendszergazdai jogosultságot.

A Jenkins beállítása után ugorjon előre a Jenkins-feladat létrehozásához és konfigurálásához.

A Jenkins beállítása Service Fabric-fürtön kívül

A Jenkinst egy Service Fabric-fürtben vagy azon kívül is beállíthatja. A következő szakaszok a fürtön kívüli beállítást mutatják be.

Győződjön meg arról, hogy a Docker telepítve van a gépen a terminálon való futtatással docker info . A kimenet azt jelzi, hogy a Docker szolgáltatás fut-e.

Ha a Docker nincs telepítve, futtassa a következő parancsokat:

sudo apt-get install wget
wget -qO- https://get.docker.io/ | sh

Kérje le a Service Fabric Jenkins-tárolójának rendszerképét: docker pull rapatchi/jenkins:latest. Ez a rendszerkép előre telepített Service Fabric Jenkins beépülő modullal rendelkezik.
Futtassa a tároló rendszerképét: docker run -itd -p 8080:8080 rapatchi/jenkins:latest
Kérje le a tárolórendszerkép-példány azonosítóját. A docker ps –a paranccsal az összes Docker-tárolót listázhatja
Jelentkezzen be a Jenkins portálra az alábbi lépésekkel:
1. Jelentkezzen be egy Jenkins-felületre a gazdagépről. Használja a tárolóazonosító első négy számjegyét. Ha például a tároló azonosítója, 2d24a73b5964használja a következőt 2d24:
```
docker exec -it [first-four-digits-of-container-ID] /bin/bash
```
2. A Jenkins-rendszerhéjból kérje le a tárolópéldány rendszergazdai jelszavát:
```
cat /var/jenkins_home/secrets/initialAdminPassword
```
3. A Jenkins-irányítópultra való bejelentkezéshez nyissa meg a következő URL-címet egy webböngészőben: http://<HOST-IP>:8080. Az előző lépés jelszavával oldja fel a Jenkins zárolását.
4. (Nem kötelező.) Az első bejelentkezés után létrehozhatja saját felhasználói fiókját, és használhatja az alábbi lépésekhez, vagy továbbra is használhatja a rendszergazdai fiókot. Ha létrehoz egy felhasználót, folytatnia kell a felhasználót.
Állítsa be a GitHubot a Jenkins használatára az új SSH-kulcs létrehozásának és az SSH-ügynökhöz való hozzáadásának lépéseivel.
- A GitHub utasításait követve hozza létre az SSH-kulcsot, majd adja hozzá ahhoz a GitHub-fiókhoz, amelyen az adattár üzemel.
- Futtassa a fenti hivatkozással elérhető parancsokat a Jenkins Docker-felületén (és ne a saját gazdagépén).
- Ahhoz, hogy a saját gazdagépéről jelentkezhessen be a Jenkinsbe, használja a következő parancsot:
```
docker exec -t -i [first-four-digits-of-container-ID] /bin/bash
```

Győződjön meg arról, hogy annak a fürtnek vagy gépnek, amelyen a Jenkins-tároló lemezképe fut, rendelkezik nyilvános IP-címmel. Ez lehetővé teszi, hogy a Jenkins-példány megkapja a GitHub értesítéseit.

A Jenkins beállítása után folytassa a következő, Jenkins-feladat létrehozása és konfigurálása című szakaszsal.

Jenkins-feladatok létrehozása és konfigurálása

Az ebben a szakaszban ismertetett lépések bemutatják, hogyan konfigurálhat Jenkins-feladatokat a GitHub-adattár változásainak megválaszolására, a módosítások beolvasására és összeállítására. A szakasz végén a rendszer az utolsó lépésekre irányítja, hogy konfigurálja a feladatot az alkalmazás üzembe helyezéséhez attól függően, hogy fejlesztési/tesztelési környezetben vagy éles környezetben helyezi üzembe.

A Jenkins-irányítópulton kattintson az Új elem elemre.
Adjon nevet az elemnek (pl. MyJob). Válassza a free-style project (szabad projekt) lehetőséget, majd kattintson az OK gombra.
Megnyílik a Feladat konfigurációs lapja. (Ha a Jenkins-irányítópulton szeretné elérni a konfigurációt, kattintson a feladatra, majd a Konfigurálás).
Az Általános lapon jelölje be a GitHub-projekt jelölőnégyzetét, és adja meg a GitHub-projekt URL-címét. Ez az URL-cím üzemelteti azt a Service Fabric Java-alkalmazást, amelyet integrálni szeretne a Jenkins folyamatos integrációs és üzembe helyezési (CI/CD) folyamatával (például: https://github.com/{your-github-account}/service-fabric-java-getting-started).
A Forráskód kezelése lapon válassza a Git lehetőséget. Adja meg annak az adattárnak az URL-címét, amely a Jenkins CI/CD folyamatával integrálni kívánt Service Fabric Java-alkalmazást tartalmazza (például: https://github.com/{your-github-account}/service-fabric-java-getting-started). Azt is megadhatja, hogy melyik ágat kell létrehozni (például /master).
Konfigurálja a GitHub-adattárat a Jenkinshez való kommunikációhoz:
1. A GitHub-adattár lapján nyissa meg a Gépház> Integrations and Services lapot.
2. Válassza a Szolgáltatás hozzáadása lehetőséget, írja be a Jenkinst, és válassza a Jenkins-GitHub beépülő modult.
3. Adja meg a Jenkins-webhook URL-címét (alapértelmezés szerint ez a következő: http://<PublicIPorFQDN>:8081/github-webhook/). Kattintson az add/update service (Szolgáltatás hozzáadása/frissítése) elemre.
4. A Jenkins-példányra egy tesztesemény érkezik. A GitHubban egy zöld pipa jelenik meg a webhook mellett, és a projekt létrejön.
A Jenkins Build Triggers lapján válassza ki a kívánt buildelési lehetőséget. Ebben a példában egy buildet szeretne aktiválni, amikor leküldés történik az adattárba, ezért válassza a GitHub hook triggert a GITScm-lekérdezéshez. (Korábban ez Build when a change is pushed to GitHub (Felépítés módosítások GitHubon való közzétételekor) volt.)
A Build lapon végezze el az alábbiak egyikét attól függően, hogy Java-alkalmazást vagy .NET Core-alkalmazást hoz létre:
- Java-alkalmazások esetén: A Build hozzáadása lépés legördülő menüben válassza a Gradle-szkript meghívása lehetőséget. Kattintson a Speciális elemre. A speciális menüben adja meg az alkalmazás gyökérszintű buildszkriptjének elérési útját. A rendszer felveszi a build.gradle elemet a megadott elérési útból, és annak megfelelően működik. Az ActorCounter alkalmazás esetében ez a következő: ${WORKSPACE}/reliable-services-actor-sample/Actors/ActorCounter.
- .NET Core-alkalmazások esetén: A Build hozzáadása lépés legördülő menüben válassza az Execute Shell (Rendszerhéj végrehajtása) lehetőséget. A megjelenő parancsmezőben először módosítani kell a könyvtárat arra az elérési útra, ahol a build.sh fájl található. A címtár módosítása után a build.sh szkript futtatható az alkalmazás létrehozásához.
```
cd /var/jenkins_home/workspace/[Job Name]/[Path to build.sh]  
./build.sh
```
  Az alábbi képernyőképen egy példa látható a Counter Service-minta létrehozásához használt parancsok közül egy Jenkins-feladat nevévelCounterServiceApplication.
Ahhoz, hogy konfigurálja a Jenkinst az alkalmazás Service Fabric-fürtön való üzembe helyezésére a buildelés utáni műveletekben, szüksége lesz a fürt tanúsítványának helyére a Jenkins-tárolóban. Válasszon az alábbiak közül attól függően, hogy a Jenkins-tároló a fürtön belül vagy kívül fut-e, és jegyezze fel a fürttanúsítvány helyét:
- A fürtben futó Jenkins esetében: A tanúsítvány elérési útja a tárolón belüli Certificates_JenkinsOnSF_Code_MyCert_PEM környezeti változó értékének visszhangzásával található.
```
echo $Certificates_JenkinsOnSF_Code_MyCert_PEM
```
- A fürtön kívül futó Jenkins esetében: A fürttanúsítvány tárolóba másolásához kövesse az alábbi lépéseket:
  1. A tanúsítványnak PEM formátumban kell lennie. Ha nem rendelkezik PEM-fájllal, létrehozhat egyet a PFX-tanúsítványfájlból. Ha a PFX-fájl nem jelszóval védett, futtassa a következő parancsot a gazdagépről:
```
openssl pkcs12 -in clustercert.pfx -out clustercert.pem -nodes -passin pass:
```
    Ha a PFX-fájl jelszóval védett, adja meg a jelszót a -passin paraméterben. Példa:
```
openssl pkcs12 -in clustercert.pfx -out clustercert.pem -nodes -passin pass:<password>
```
  2. A Jenkins-tároló tárolóazonosítójának lekéréséhez futtassa docker ps a gazdagépről.
  3. Másolja a PEM-fájlt a tárolóba a következő Docker-paranccsal:
```
docker cp clustercert.pem [first-four-digits-of-container-ID]:/var/jenkins_home
```

Majdnem elkészült! Hagyja nyitva a Jenkins-munkát. Az egyetlen fennmaradó feladat az alkalmazás Service Fabric-fürtben való üzembe helyezésének összeállítás utáni lépéseinek konfigurálása:

Fejlesztési vagy tesztelési környezetben való üzembe helyezéshez kövesse az Üzembe helyezés konfigurálása fürtkezelési végponttal című témakörben leírt lépéseket.
Éles környezetben való üzembe helyezéshez kövesse az Üzembe helyezés konfigurálása Azure-hitelesítő adatokkal című szakasz lépéseit.

Üzembe helyezés konfigurálása fürtfelügyeleti végponttal

Fejlesztési és tesztelési környezetek esetén a fürtfelügyeleti végpontot használhatja az alkalmazás üzembe helyezéséhez. A buildelés utáni művelet fürtkezelési végponttal való konfigurálásához az alkalmazás üzembe helyezéséhez a legkevesebb beállítás szükséges. Ha éles környezetben helyezi üzembe az üzembe helyezést, ugorjon előre az üzembe helyezés Azure-hitelesítő adatokkal történő konfigurálásához, hogy konfiguráljon egy Microsoft Entra szolgáltatásnevet az üzembe helyezés során.

A Jenkins-feladatban kattintson a Létrehozás utáni műveletek fülre .
A Post-Build Actions (Felépítés utáni műveletek) legördülő menüből válassza a Deploy Service Fabric Project (Service Fabric-projekt üzembe helyezése) elemet.
A Service Fabric-fürt konfigurációja területen válassza a Service Fabric felügyeleti végpontjának kitöltése választógombot.
A Felügyeleti gazdagép esetében adja meg a fürt kapcsolati végpontját, például{your-cluster}.eastus.cloudapp.azure.com.
Ügyfélkulcs és ügyfél-tanúsítvány esetén adja meg a PEM-fájl helyét a Jenkins-tárolóban, például/var/jenkins_home/clustercert.pem. (A tanúsítvány helyét a következő utolsó lépésben másolta:Jenkins-feladat létrehozása és konfigurálása.)
Az Alkalmazáskonfiguráció területen konfigurálja az alkalmazás nevét, az alkalmazás típusát és az alkalmazásjegyzék mezőinek (relatív) elérési útját.
Kattintson a Konfiguráció ellenőrzése elemre. Sikeres ellenőrzés után kattintson a Mentés gombra. A Jenkins-feladatfolyamat most már teljesen konfigurálva van. Az üzembe helyezés teszteléséhez ugorjon a Következő lépésekre .

Üzembe helyezés konfigurálása Azure-hitelesítő adatokkal

Éles környezetekben erősen ajánlott azure-hitelesítő adatokat konfigurálni az alkalmazás üzembe helyezéséhez. Ez a szakasz bemutatja, hogyan konfigurálhat egy Microsoft Entra-szolgáltatásnevet az alkalmazás üzembe helyezéséhez a buildelés utáni műveletben. A Jenkins-feladat engedélyeinek korlátozásához szolgáltatásnevek rendelhetők hozzá a címtárban lévő szerepkörökhöz.

Fejlesztési és tesztelési környezetek esetén az alkalmazás üzembe helyezéséhez azure-beli hitelesítő adatokat vagy fürtkezelési végpontot is konfigurálhat. A fürtkezelési végpontok konfigurálásáról további információt a Fürtkezelési végpont használatával történő üzembe helyezés konfigurálása című témakörben talál.

Ha Microsoft Entra-szolgáltatásnevet szeretne létrehozni, és engedélyeket szeretne hozzárendelni az Azure-előfizetéséhez, kövesse a Microsoft Entra-alkalmazás és -szolgáltatásnév létrehozásához a portál használatával kapcsolatos lépéseket. Ügyeljen a következőkre:
- A témakör lépéseit követve mindenképpen másolja és mentse a következő értékeket: alkalmazásazonosító, alkalmazáskulcs, címtárazonosító (bérlőazonosító) és előfizetés-azonosító. Szüksége van rájuk az Azure-hitelesítő adatok Jenkinsben való konfigurálásához.
- Ha nem rendelkezik a szükséges engedélyekkel a címtárban, meg kell kérnie a rendszergazdát, hogy adja meg Önnek az engedélyeket, vagy hozza létre a szolgáltatásnevet, vagy konfigurálnia kell a fürt felügyeleti végpontját a Jenkinsben végzett feladat build utáni műveleteiben.
- A Microsoft Entra-alkalmazás létrehozása szakaszban bármilyen jól formázott URL-címet megadhat a bejelentkezési URL-címhez.
- Az Alkalmazás hozzárendelése szerepkörhöz szakaszban hozzárendelheti az alkalmazást olvasó szerepkörhöz a fürt erőforráscsoportjában.
A Jenkins-feladatban kattintson a Létrehozás utáni műveletek fülre .
A Post-Build Actions (Felépítés utáni műveletek) legördülő menüből válassza a Deploy Service Fabric Project (Service Fabric-projekt üzembe helyezése) elemet.
A Service Fabric-fürt konfigurációja csoportban kattintson a Service Fabric-fürt kiválasztása elemre. Kattintson a Hozzáadás gombra az Azure Credentials mellett. A Jenkins hitelesítő adatok szolgáltatójának kiválasztásához kattintson a Jenkins elemre.
A Jenkins hitelesítőadat-szolgáltatóban válassza a Microsoft Azure Szolgáltatásnév lehetőséget a Kind legördülő listában.
Az 1. lépésben a szolgáltatásnév beállításakor mentett értékekkel állítsa be a következő mezőket:
- Ügyfélazonosító: Alkalmazásazonosító
- Titkos ügyfélkód: Alkalmazáskulcs
- Bérlőazonosító: Címtárazonosító
- Előfizetés azonosítója: Előfizetés azonosítója
Adjon meg egy leíró azonosítót , amellyel kiválaszthatja a hitelesítő adatokat a Jenkinsben, valamint egy rövid leírást. Ezután kattintson a Szolgáltatásnév ellenőrzése elemre. Ha az ellenőrzés sikeres, kattintson a Hozzáadás gombra.
A Service Fabric-fürtkonfiguráció alatt győződjön meg arról, hogy az új hitelesítő adatok ki lesznek választva az Azure hitelesítő adataihoz.
Az Erőforráscsoport legördülő listában válassza ki annak a fürtnek az erőforráscsoportját, amelybe telepíteni szeretné az alkalmazást.
A Service Fabric legördülő listában válassza ki azt a fürtöt, amelybe telepíteni szeretné az alkalmazást.
Ügyfélkulcs és ügyfél-tanúsítvány esetén adja meg a PEM-fájl helyét a Jenkins-tárolóban. Például: /var/jenkins_home/clustercert.pem.
Az Alkalmazáskonfiguráció területen konfigurálja az alkalmazás nevét, az alkalmazás típusát és az alkalmazásjegyzék mezőinek (relatív) elérési útját.
Kattintson a Konfiguráció ellenőrzése elemre. Sikeres ellenőrzés után kattintson a Mentés gombra. A Jenkins-feladatfolyamat most már teljesen konfigurálva van. Folytassa a következő lépésekkel az üzembe helyezés teszteléséhez.

A Jenkins beépülő modul hibaelhárítása

Ha hibát tapasztal a Jenkins beépülő modullal, küldjön egy hibát a Jenkins JIRA-ban az adott összetevőhöz.

Kipróbálandó ötletek

A GitHub és a Jenkins beállítása kész. Fontolja meg, hogy néhány mintamódosítást végez a reliable-services-actor-sample/Actors/ActorCounter projektben az adattár elágazásában. https://github.com/Azure-Samples/service-fabric-java-getting-started Küldje el a módosításokat a távoli master ágra (vagy bármely olyan ágra, amellyel konfigurálta, hogy működjön). Ez aktiválja a konfigurált MyJob Jenkins-feladatot. Lekéri a módosításokat a GitHubról, létrehozza és üzembe helyezi az alkalmazást a buildelés utáni műveletekben megadott fürtön.

Következő lépések

A Jenkins az Azure-on

Share via