Megosztás a következőn keresztül:

Üzembe helyezés Linux rendszerű virtuális gépeken egy környezetben

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022 | Azure DevOps Server 2020

Az Azure Pipelines-környezetekben erőforrásokként adhat hozzá virtuális gépeket, és üzembe helyezés céljából megcélzhatja őket. A folyamatos integrációs és folyamatos üzembe helyezési (CI/CD) munkafolyamat esetében a környezet üzembe helyezési előzményei nyomon követhetőséget biztosítanak az egyes virtuális gépek számára az eseményindító véglegesítésig.

Ez a cikk bemutatja, hogyan állíthat be Egy Azure DevOps-folyamatot több Linux rendszerű virtuálisgép-erőforrás üzembe helyezéséhez egy környezetben. Ezek az utasítások JavaScript- vagy Java-alkalmazásokat építenek ki és helyeznek üzembe, de bármely webterjesztési csomagot közzétevő alkalmazáshoz igazíthatja őket.

Az üzembe helyezési feladat által megcélzott környezetekről és erőforrásokról további információt a jobs.deployment.environment YAML sémadefinícióban talál. Az üzembehelyezési feladatokról további információt a jobs.deployment definícióban talál.

Előfeltételek

JavaScript- vagy Node.js-alkalmazások esetén is:

Fontos

  • Az alkalmazások telepítéséhez a célkörnyezeti virtuálisgép-erőforrásoknak telepítve és konfigurálva kell lenniük az összes szükséges szoftvernek, függőségnek, engedélynek és bejelentkezésnek.
  • A GitHub-forráskód használatához GitHub-szolgáltatáskapcsolatra van szükség. A GitHub arra is megkérheti, hogy jelentkezzen be, telepítse az Azure Pipelines GitHub alkalmazást, vagy engedélyezze az Azure Pipelinest. Az egyes folyamatok elvégzéséhez kövesse a képernyőn megjelenő utasításokat. További információ: Hozzáférés a GitHub-adattárakhoz.

Környezet létrehozása és Linux rendszerű virtuális gépek hozzáadása

Az Azure Pipelines-projektben hozzon létre egy környezetet, és adja hozzá a Linux rendszerű virtuális gépeket környezeti erőforrásként a Környezet létrehozása és virtuális gép hozzáadása című témakör utasításait követve.

Futtassa a másolt ügynökregisztrációs szkriptet minden egyes virtuális gépen, hogy az regisztrálva legyen a környezetben. Az interaktív kérdések megválaszolásával címkéket is hozzárendelhet az egyes virtuális gépekhez.

A buildelési folyamat létrehozása és futtatása

Hozzon létre egy CI-folyamatot, amely létrehozza és üzembe helyezi az alkalmazást, amikor véglegesítés van a main kódtár ágában.

A YAML-folyamat létrehozása

  1. Az Azure DevOps-projektben válassza a Pipelines>New pipeline vagy a Create Pipeline lehetőséget, majd válassza a GitHubot a forráskód helyeként.
  2. A repozitórium kiválasztása képernyőn válassza ki a forkolt mintaadattárat.
  3. A Folyamat konfigurálása képernyőn válassza a Kezdő folyamatot.
  4. A folyamat YAML-jének áttekintése képernyőn cserélje le a létrehozott kezdőkódot a következő kódra a futtatókörnyezettől függően.

Build feladat hozzáadása

A Build feladat feladatokat futtat a projekt összeállításához és teszteléséhez, és feltölti a build kimenetét egy drop helyre. Ez a feladat a folyamatban poolmegadott buildügynökökön fut, nem a Linux-környezetbeli virtuális gépeken.

Az alábbi folyamat npm-lel hozza létre és teszteli a Node.js projektet, majd csomagolja a kimenetet, és feltölti egy drop helyre.

trigger:
- main

pool:
  vmImage: ubuntu-latest

jobs:  
- job: Build
  displayName: Build
  steps:
  - task: UseNode@1
    inputs:
      version: '16.x'
    displayName: 'Install Node.js'
  - script: |
      npm install
      npm run build --if-present
      npm run test --if-present
    displayName: 'npm install, build and test'
  - task: ArchiveFiles@2
    displayName: 'Archive files'
    inputs:
      rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
      includeRootFolder: false
      archiveType: tar
      tarCompression: gz
      archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).gz
      replaceExistingArchive: true
  - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).gz
    artifact: drop

További információkért tekintse át a build létrehozásának lépéseit a Node.js-alkalmazás buildeléséhez a Gulp használatával.

Csővezeték futtatása

A azure-pipelines.yml fájl adattárba mentéséhez és a CI/CD-folyamat elindításához válassza a Mentés és futtatás, majd a Mentés és futtatás lehetőséget.

Amikor a folyamat befejeződött, tekintse meg a feladat összegzési oldalát annak ellenőrzéséhez, hogy a buildelési feladat sikeresen futott-e, és hogy 1 közzétett összetevő jelenik-e meg a Kapcsolódó területen.

Az üzembehelyezési feladat hozzáadása és futtatása

Az üzembehelyezési feladat egyszer végrehajtja a preDeploy, deploy, routeTraffic és postRouteTraffic életciklus-horgokat, majd végrehajtja vagy a on: success-t vagy a on: failure-t. Ha környezeti virtuális gépeken helyezi üzembe, a fázis a preDeploy build ügynökön fut, nem a környezeti virtuális gépeken. Az összes többi lépés a környezetben regisztrált virtuális gépeken fut.

  1. Az opcionális preDeploy lépés az üzembe helyezés előtt fut. Az feladatot orchestrációhoz, virtuális gépek előkészítéséhez, artifaktumok előkészítéséhez, valamint állapotellenőrzésekhez használhatja.
  2. A deploy lépés üzembe helyezi az üzembehelyezési objektumot a célkörnyezeti virtuális gépeken.
  3. Az opcionális routeTraffic lépés a forgalomváltást is alkalmazhatja.
  4. Az opcionális postRouteTraffic lépés állapotellenőrzéseket és értesítéseket végezhet.
  5. Az egyéni on.failure és on.success a lépések értesítéseket vagy helyreállítást biztosíthatnak.

Egy környezetbe resourceType: VirtualMachine irányuló üzembehelyezési feladathoz a környezeti virtuális gépeknek minden folyamatfeladatot futtatniuk kell, például a Basht vagy az Azure CLI-t. A lépés segítségével telepítheti a preDeploy szükséges szoftvereket és engedélyeket a cél virtuális gépeken.

Ha például egy üzembe helyezési lépés az Azure CLI-t használja, az ügynök virtuális gépeinek telepítve kell lenniük az Azure CLI-vel, és elérhetővé kell lenniük az ügynökfelhasználó ELÉRÉSI ÚTJÁN. Az ügynökfelhasználónak engedéllyel kell rendelkeznie a parancssori felület futtatásához, és hitelesítenie kell magát az Azure-ban. Előfordulhat, hogy hozzá kell adnia az ügynök felhasználóját a sudoershez, vagy környezeti változókat kell beállítania a telepítés automatizálásához.

Egy szkripttel preDeploy telepítheti az Azure CLI-t a cél virtuális gépekre. Az Azure-val történő hitelesítéshez futtathat az login, vagy automatizálás céljából definiálhat egy szolgáltatásnevű objektumot, és futtathat az login --service-principal egy preDeploy lépésben.

Az üzembehelyezési feladat hozzáadása

A következő példa üzembehelyezési feladat a Build feladat sikeres befejezését követően indul el. A feladat hozzáadása a folyamathoz:

  1. Válassza az Összefoglalás lap jobb felső részén található További műveletek ikont, válassza a Folyamat szerkesztése lehetőséget, és adja hozzá a következő kódot a folyamat végéhez. Cserélje le <environment-name> a létrehozott környezet nevére.

    Ha szeretné, kiválaszthat bizonyos virtuális gépeket a környezetből az üzembe helyezés fogadásához a tags paraméterrel, és megadhatja a <VMtag> virtuális géphez megadott értéket.

    - deployment: VMDeploy
  displayName: Web deploy
  dependsOn: Build
  condition: succeeded()
  environment:
    name: <environment-name>
    resourceType: VirtualMachine
    tags: <VMtag> # VMs to deploy to

  2. Adjon hozzá egy strategy elemet a deployment feladathoz. A runOnce telepítési stratégia a legegyszerűbb, és alapértelmezés szerint fut, ha nem adja meg strategy. Ez a stratégia egyszer hajtja végre az üzembe helyezési lépéseket a környezet minden virtuális gépén, párhuzamosság vagy forgalomkezelés nélkül.

      strategy:
     runOnce:
       deploy:
          steps:
          - script: echo my first deployment

  3. Az üzembe helyezési feladat hozzáadása után válassza az Ellenőrzés és mentés, majd a Mentés, a Futtatás, majd a Futtatás újra lehetőséget. Az ütem minden futtatásakor az üzembe helyezési előzmények rekordjai az adott környezethez viszonyítva lesznek rögzítve.

    Feljegyzés

    Amikor először futtatja a környezetet használó folyamatot, engedélyt kell adnia a folyamat összes futtatására az ügynökkészlet és a környezet eléréséhez. Válassza a Folyamatfuttatásösszegzése képernyőn a feladat melletti Várakozás szimbólumot, majd válassza az Engedélyezés lehetőséget a szükséges engedélyek megadásához.

Szakaszos üzembe helyezési stratégia

Az üzembe helyezési rolling stratégia helyett használhatja a következőtrunOnce: A gördülő üzembehelyezési stratégia képes vezérelni a párhuzamosságot, az állapot-ellenőrzéseket és a forgalomirányítást. Bár a runOnce stratégia egyszerre egyetlen virtuális gépen fut, a működés közbeni üzembe helyezés a beállítástól függően maxParallel akár öt cél virtuális gépen is futtatható párhuzamosan.

A maxParallel paraméter beállítja azoknak a virtuális gépeknek a számát vagy százalékát, amelyeknek elérhetőnek kell maradniuk, biztosítva, hogy az alkalmazás kezelni tudja a kéréseket, és csökkentse a telepítések során fellépő állásidőt. Ez a paraméter az üzembe helyezés sikeres és sikertelen feltételeit is meghatározza.

A működés közbeni üzembe helyezési stratégiáról további információt a jobs.deployment.strategy.rolling sémadefinícióban talál.

Példa üzembehelyezési feladatra

A virtuálisgép-erőforrások üzembe helyezéséhez a virtuális gépeknek telepítve és konfigurálva kell lenniük az összes szükséges alkalmazásnak, függőségnek és engedélynek. Manuálisan kell előre telepítenie ezeket a követelményeket, vagy a folyamatnak telepítenie vagy implementálnia kell őket.

A Java-alkalmazás virtuálisgép-erőforrásokon való üzembe helyezése egyszerűbben implementálható, mert önálló. A Java virtuális gépet (JVM) gyakran előtelepítik a virtuálisgép-ügynökökre, és nem kell aggódnia az alkalmazásfüggőségek, az engedélyek vagy a csomagkezelés miatt. Egyszerűen letöltheti a JAR-fájlt, majd futtathatja a következővel java -jar: .

A Node.js alkalmazáshoz node-ra, esetleg npm-függőségekre, valamint egy olyan szolgáltatáskezelőre van szükség, mint a systemd, hogy minden ügynök virtuális gépen jelen legyen és konfigurálva legyen. Az automatizáláshoz a folyamat üzembehelyezési szkriptjének neminteraktívnak kell lennie, és képesnek kell lennie az alkalmazás szolgáltatásának újraindítására és kezelésére.

A JavaScript-alkalmazás következő YAML-üzembehelyezési rolling feladata a fázis sikeres Build befejezésétől függ. Az üzembe helyezési feladat feltételezi, hogy az alábbi követelmények már előre telepítve vannak vagy előre konfigurálva vannak minden ügynök virtuális gépen. A teljes automatizálás érdekében ezeket az alkalmazásokat és szolgáltatásokat a folyamat részeként telepítheti és konfigurálhatja a virtuális gépeken.

  • Node.js 16.x van telepítve, és az npm elérhető a buildügynök PATH-ján.
  • A rendszer egy rendszeralapú szolgáltatásfájllal van konfigurálva a Node.js alkalmazás elindításához, ilyen például /etc/systemd/system/pipelines-javascript.service.
  • A jelszó nélküli sudo engedélyezése az ügynök felhasználó számára szükséges parancsokhoz a NOPASSWD: fájlban lévő beállításokkal.
  • Írási engedélyek az ügynök felhasználója számára a /opt/pipelines-javascript vagy más üzembehelyezési cél számára.

Jótanács

A legtöbb Node.js alkalmazás esetében fontolja meg az Azure App Service-ben való üzembe helyezést, vagy a Microsoft által üzemeltetett ügynökökkel végzett rendszeres folyamatfeladatok használatát az üzembehelyezési feladatok használata helyett. Ez a megközelítés egyszerűbb, és elkerüli a virtuálisgép-környezetek kezelésével kapcsolatos üzemeltetési többletterhelést. Az adott virtuálisgép-erőforrások üzembe helyezése a legjobban a virtuálisgép-kiszolgálók közvetlen vezérlését, a speciális vezénylést vagy az örökölt infrastruktúrát igénylő forgatókönyvekhez ideális.

- stage: Deploy
  displayName: Rolling Deploy to VMs
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: RollingDeploy
    displayName: Rolling deploy to Ubuntu VMs
    environment:
      name: <environment-name>
      resourceType: VirtualMachine
    strategy:
      rolling:
        maxParallel: 1   #or 2 for parallel. For percentages, use x%
        preDeploy:
          steps:
          - download: current
            artifact: drop
          - script: echo "Pre-deploy on $(hostname)"
        deploy:
          steps:
          - script: |
              echo "Unpacking Node.js app on $(hostname)"
              sudo mkdir -p /opt/pipelines-javascript
              sudo tar -xzf $(Pipeline.Workspace)/drop/$(Build.BuildId).tar.gz -C /opt/pipelines-javascript --strip-components=1
              cd /opt/pipelines-javascript
              echo "Installing production dependencies"
              sudo npm ci --only=production
              echo "Restarting Node.js service"
              sudo systemctl restart pipelines-javascript
            displayName: 'Extract, install, and restart Node.js service'
        routeTraffic:
          steps:
          - script: echo "Routing traffic on $(hostname)"
        postRouteTraffic:
          steps:
          - script: echo "Post-route health check on $(hostname)"
        on:
          failure:
            steps:
            - script: echo "Deployment failed on $(hostname)"
          success:
            steps:
            - script: echo "Deployment succeeded on $(hostname)"

Hozzáférési folyamat nyomon követhetősége a környezetben

A Környezettelepítések lap a véglegesítések és a munkaelemek teljes nyomon követhetőségét, valamint a környezet folyamatközi üzembe helyezési előzményeit biztosítja.

Képernyőkép az üzembe helyezési nézetről.

Kapcsolódó tartalom

  • Last updated on