Als Automation Pipelines-beheerder of -ontwikkelaar kunt u Automation Pipelines en VMware Tanzu Kubernetes Grid Integrated Edition (voorheen VMware Enterprise PKS genoemd) gebruiken om de implementatie van uw softwareapplicaties naar een Kubernetes-cluster te automatiseren. Dit toepassingsvoorbeeld vermeldt andere methoden die u kunt gebruiken om de release van uw applicatie te automatiseren.

In dit toepassingsvoorbeeld maakt u een pijplijn die twee fasen bevat en gebruikt u Jenkins om uw applicatie te bouwen en te implementeren.

  • De eerste fase is voor ontwikkeling. Deze gebruikt Jenkins om uw code uit een tak in uw GitHub-opslagplaats te halen en deze vervolgens te bouwen, te testen en te publiceren.
  • De tweede fase is voor de implementatie. Er wordt een gebruikersbewerkingstaak uitgevoerd die moet worden goedgekeurd door belangrijke gebruikers voordat de pijplijn uw applicatie naar uw Kubernetes-cluster kan implementeren.

Wanneer u een Kubernetes API-eindpunt in de pijplijnwerkplek gebruikt, maakt Automation Pipelines de nodige Kubernetes-resources zoals ConfigMap, Geheim en Pod om de taak voor continue integratie (CI) of de aangepaste taak uit te voeren. Automation Pipelines communiceert met de container via de NodePort.

Als u gegevens wilt delen tussen pijplijnuitvoeringen, moet u een permanente volumeclaim opgeven, en Automation Pipelines koppelt de permanente volumeclaim aan de container om de gegevens op te slaan en deze te gebruiken voor volgende pijplijnuitvoeringen.

De Automation Pipelines-pijplijnwerkplek ondersteunt Docker en Kubernetes voor taken voor continue integratie en aangepaste taken.

Zie De pijplijnwerkplek configureren voor meer informatie over het configureren van de werkplek.

De werkstroom die een applicatie implementeert op een Kubernetes-cluster gebruikt Jenkins, Automation Pipelines, GitHub, de trigger voor Git en Kubernetes.

De ontwikkelingstools, implementatie-instanties en het YAML-bestand van de pijplijn moeten beschikbaar zijn zodat uw pijplijn uw applicatie kan bouwen, testen, publiceren en implementeren. De pijplijn implementeert uw applicatie naar ontwikkelings- en productie-instanties van Kubernetes-clusters.

De werkstroom helpt u bij het navigeren door het proces waarmee een applicatie in een Kubernetes-cluster vrijkomt.

Andere methoden die de release van uw applicatie automatiseren:

  • In plaats van uw applicatie met Jenkins te bouwen kunt u de systeemeigen bouwmogelijkheid van Automation Pipelines en een Docker-buildhost gebruiken.
  • In plaats van uw applicatie in een Kubernetes-cluster te implementeren kunt u deze ook implementeren in een Amazon Web Services-cluster (AWS).

Zie voor meer informatie over het gebruik van de systeemeigen bouwmogelijkheid vanAutomation Pipelines en een Docker-host:

Voorwaarden

  • Controleer of de applicatiecode die moet worden geïmplementeerd, zich in een werkende GitHub-opslagplaats bevindt.
  • Controleer of u over een werkende instantie van Jenkins beschikt.
  • Controleer of u over een werkende e-mailserver beschikt.
  • Maak in Automation Pipelines een e-mail-eindpunt dat verbinding maakt met uw e-mailserver.
  • Stel twee Kubernetes-clusters in op Amazon Web Services (AWS) voor ontwikkeling en productie, waar uw-pijplijn uw applicatie zal implementeren.
  • Controleer of de GitHub-opslagplaats de YAML-code voor uw pijplijn bevat of een YAML-bestand waarmee de metagegevens en specificaties voor uw omgeving worden gedefinieerd.

Procedure

  1. Klik in Automation Pipelines op Eindpunten > Nieuw eindpunt en maak een Jenkins-eindpunt dat u in uw pijplijn zult gebruiken om code uit uw GitHub-opslagplaats te halen.
  2. Als u Kubernetes-eindpunten wilt maken, klikt u op Nieuw eindpunt.
    1. Maak een eindpunt voor uw Kubernetes-cluster voor ontwikkeling.
    2. Maak een eindpunt voor uw Kubernetes-cluster voor productie.
      De URL voor uw Kubernetes-cluster kan een poortnummer bevatten of niet.
      Bijvoorbeeld:
      https://10.111.222.333:6443
      https://api.kubernetesserver.fa2c1d78-9f00-4e30-8268-4ab81862080d.k8s-user.com
  3. Maak een pijplijn die een container van uw applicatie, zoals WordPress, implementeert op uw Kubernetes-cluster voor ontwikkeling en stel de inputproperties voor de pijplijn in.
    1. Om ervoor te zorgen dat uw pijplijn een code-commit in GitHub herkent die de pijplijn activeert, klikt u in de pijplijn op het tabblad Input en selecteert u Properties automatisch injecteren.
    2. Voeg de eigenschap met de naam GIT_COMMIT_ID toe en klik op de bijbehorende ster.
      Wanneer de pijplijn wordt uitgevoerd, wordt in de pijplijn-uitvoering de commit-ID weergegeven die door de Git-trigger wordt geretourneerd.
    In een pijplijn die Jenkins en Kubernetes gebruikt, worden op het tabblad Invoer de Git-invoereigenschappen weergegeven.
  4. Voeg meldingen toe om een e-mail te verzenden wanneer de pijplijn slaagt of mislukt.
    1. Klik in de pijplijn op het tabblad Meldingen en klik op Toevoegen.
    2. Om een e-mailmelding toe te voegen voor het voltooien van de pijplijn, selecteert u E-mail en selecteert u Voltooit. Selecteer vervolgens de e-mailserver, voer de e-mailadressen in en klik op Opslaan.
    3. Om nog een e-mailmelding toe te voegen voor een pijplijnfout, selecteert u Mislukt en klikt u op Opslaan.
    Wanneer u een e-mailmelding toevoegt, selecteert u een van de pijplijnstatussen en selecteert u de e-mailserver en ontvangers.
  5. Voeg een ontwikkelingsfase toe aan uw pijplijn en voeg taken toe die uw applicatie bouwen, testen en publiceren. Vervolgens valideert u elke taak.
    1. Om uw applicatie te bouwen, voegt u een Jenkins-taak toe die het Jenkins-eindpunt gebruikt en voert u een bouwtaak uit op de Jenkins-server. Voer vervolgens de Git-tak in deze vorm in, zodat de-pijplijn uw code kan ophalen: ${input.GIT_BRANCH_NAME}
    2. Om uw applicatie te testen, voegt u een Jenkins-taak toe die hetzelfde Jenkins-eindpunt gebruikt, en voert u een testtaak uit op de Jenkins-server. Voer vervolgens dezelfde Git-tak in.
    3. Als u uw applicatie wilt publiceren, voegt u een Jenkins-taak toe die hetzelfde Jenkins-eindpunt gebruikt, en voert u een publicatietaak uit vanaf de Jenkins-server. Voer vervolgens dezelfde Git-tak in.
    In een pijplijn die gebruikmaakt van Jenkins en Kubernetes, gebruikt de Jenkins-taak die de applicatie bouwt, het Jenkins-eindpunt, de Jenkins-opdracht en de taknaam.
  6. Voeg een implementatiefase toe aan uw pijplijn en voeg vervolgens een taak toe die een goedkeuring vereist voor de implementatie van uw applicatie en een andere taak die de applicatie implementeert op uw Kubernetes-cluster. Vervolgens valideert u elke taak.
    1. Om een goedkeuring te vereisen voor de implementatie van uw applicatie, voegt u een gebruikersbewerkingstaak toe, voegt u de e-mailadressen toe voor de gebruikers die deze moeten goedkeuren en voert u een bericht in. Schakel vervolgens E-mail verzenden in.
    2. Als u uw applicatie wilt implementeren, voegt u een Kubernetes-taak toe. Selecteer vervolgens in de properties van de Kubernetes-taak uw Kubernetes-cluster voor ontwikkeling, selecteer de actie Maken en selecteer de ladingsbron Lokale definitie. Selecteer vervolgens uw lokale YAML-bestand.
  7. Voeg een Git-webhook toe die Automation Pipelines in staat stelt om de Git-trigger te gebruiken, waarmee de pijplijn wordt geactiveerd wanneer ontwikkelaars hun code doorvoeren.
    In de webhook voor Git die de Kubernetes-pijplijn activeert, moet u de tak en een geheim token invoeren.
  8. Als u uw pijplijn wilt testen, gaat u naar uw GitHub-opslagplaats, werkt u het YAML-bestand van uw applicatie bij en voert u de wijziging door.
    1. Controleer in Automation Pipelines of de commit wordt weergegeven.
    1. Klik op Triggers > Git > Activiteit.
    2. Zoek naar de trigger van uw pijplijn.
    3. Klik op Dashboards > Pijplijndashboards.
    4. Zoek in het pijplijndashboard naar de GIT_COMMIT_ID in het laatste gelukte wijzigingsgebied.
  9. Controleer de pijplijncode en verifieer of de wijziging wordt weergegeven.

resultaten

Gefeliciteerd! U heeft de implementatie van uw softwareapplicatie op uw Kubernetes-cluster geautomatiseerd.

Voorbeeld: Voorbeeld van een pijplijn-YAML die een applicatie implementeert op een Kubernetes-cluster

Voor het type pijplijn dat in dit voorbeeld wordt gebruikt, lijkt de YAML op de volgende code: 

apiVersion: v1
kind: Namespace
metadata:
  name: ${input.GIT_BRANCH_NAME}
  namespace: ${input.GIT_BRANCH_NAME}
---  
apiVersion: v1
data:
  .dockercfg: eyJzeW1waG9ueS10YW5nby1iZXRhMi5qZnJvZy5pbyI6eyJ1c2VybmFtZSI6InRhbmdvLWJldGEyIiwicGFzc3dvcmQiOiJhRGstcmVOLW1UQi1IejciLCJlbWFpbCI6InRhbmdvLWJldGEyQHZtd2FyZS5jb20iLCJhdXRoIjoiZEdGdVoyOHRZbVYwWVRJNllVUnJMWEpsVGkxdFZFSXRTSG8zIn19
kind: Secret
metadata:
  name: jfrog
  namespace: ${input.GIT_BRANCH_NAME}
type: kubernetes.io/dockercfg
---   
apiVersion: v1
kind: Service
metadata:
  name: pipelines
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: pipelines
spec:
  ports:
    - port: 80
  selector:
    app: pipelines
    tier: frontend
  type: LoadBalancer 
---
apiVersion: extensions/v1
kind: Deployment
metadata:
  name: pipelines
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: pipelines
spec:
  selector:
    matchLabels:
      app: pipelines
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: pipelines
        tier: frontend
    spec:
      containers:
      - name: pipelines
        image: cas.jfrog.io/pipelines:${input.GIT_BRANCH_NAME}-${Dev.PublishApp.output.jobId}
        ports:
        - containerPort: 80
          name: pipelines
      imagePullSecrets:
      - name: jfrog

Volgende stappen

Als u uw softwareapplicatie wilt implementeren op uw Kubernetes-cluster voor productie, voert u de stappen opnieuw uit en selecteert u uw productiecluster.

Voor meer informatie over het integreren van Automation Pipelines met Jenkins, raadpleegt u Hoe integreer ik Automation Pipelines met Jenkins?.