Azure Pipelines-tutorial: Een complete CI/CD-gids voor beginners

Als je CI/CD-pipeline steeds stukloopt of traag en stroperig aanvoelt, ben je niet de enige. Ik heb te maken gehad met mislukte builds, niet-overeenkomende omgevingen en teamgenoten die per ongeluk mijn werk overschreven. Azure Pipelines haalt deze frustraties weg met een cloud-hosted service die bijna elk project op elk platform kan bouwen, testen en deployen.

Daarom laat ik je in deze tutorial zien hoe je:

1. Je eerste Azure Pipeline maakt
2. Je project in de cloud bouwt
3. Geautomatiseerde tests toevoegt om fouten vroeg te vangen
4. Met één push naar staging of productie deployt
5. Je pipeline monitort en optimaliseert voor snelheid en betrouwbaarheid
6. Best practices volgt die zich in echte projecten hebben bewezen

Laten we beginnen!

Wat is Azure Pipelines?

Azure Pipelines is een cloudgebaseerde oplossing die het ontwikkelen, testen en deployen van applicaties vereenvoudigt. 

Het is een onderdeel van de Azure DevOps-toolkit, die de volledige softwareontwikkelingscyclus ondersteunt. Het is ook een flexibele optie voor teams van elke grootte, omdat het verschillende platforms en programmeertalen ondersteunt. Het is geïntegreerd met GitHub, Azure Repos en andere bekende versiesystemen. 

De kernfuncties van Azure Pipelines zijn: 

Uit mijn ervaring is Azure Pipelines nuttig voor iedereen die binnen zijn team proper CI/CD wil realiseren. Het is flexibel, schaalbaar en integreert goed met andere Azure services.

Azure Pipelines-architectuur (Bron: Microsoft).

Als je een bredere kijk op Azure DevOps zoekt dan alleen pipelines, dan Azure DevOps-tutorial loopt het volledige CI/CD-traject van begin tot eind door.

Je eerste Azure Pipeline opzetten

Om met de Azure Pipelines-omgeving te werken, moeten we eerst alles inrichten om een end-to-end build-, test- en deploymentproces te ondersteunen.

Vereisten

Voordat je je eerste pipeline gaat maken, zorg dat je het volgende hebt:

1. Azure DevOps-account en organisatie ingesteld: Meld je aan voor een Azure DevOps-account als je er nog geen hebt. Maak een organisatie om je projecten te beheren. 
2. Repository: Je hebt een coderepository met een voorbeeldproject nodig. Dit kan gehost worden in Azure Repos of GitHub. Voor deze tutorial gebruiken we een eenvoudig Node.js-project.
3. Toegang tot Azure-portal: Je hebt ook toegang nodig tot de Azure-portal wanneer je wilt deployen naar Azure-services zoals Azure Kubernetes Service (AKS) en nog veel meer.

Als je je kennis van het bredere Azure-ecosysteem wilt opfrissen, raad ik de cursus Understanding Microsoft Azure aan. 

Een nieuw project en repository aanmaken

Nu je Azure DevOps-account en -organisatie klaar zijn, gaan we ons eerste project en repository maken.

• Maak een nieuw project:
  • Log in op je Azure DevOps-account.
  • Klik op New Project, geef het een naam (bijv. "AzureDevOps-DataCamp-Tutorial"), en kies de zichtbaarheid (public of private).
  • Klik op Create Project.

• Een repository instellen:
  • Als je Azure Repos gebruikt, ga dan naar de sectie Repos en initialiseer een nieuwe repository.
  • Je kunt ook een bestaande GitHub-repository koppelen door Import Repository te selecteren.
  • Geef je repository een naam, kies je Repository type (Git of TFVC), plak je gekloonde repository-URL en klik op Import.

• Als je GitHub gebruikt, kun je je GitHub-account koppelen aan Azure DevOps door linksonder in je projectinterface te gaan naar Project Settings > GitHub Connections > Connect your GitHub account te selecteren.

Voor deze tutorial gebruiken we Azure Repos als onze coderepository. Als je net begint of geen specifieke reden hebt om TFVC te kiezen, raad ik je aan om voor Git te gaan.

Je eerste pipeline maken

Het is tijd om onze eerste pipeline te maken. Volg de onderstaande stappen:

• Klik in je Pipelines-sectie op Create Pipeline.

• Selecteer Azure Repos Git als bron en kies je repository.

• Je kunt je pipeline configureren met de YAML- of Classic-editor. We kiezen voor YAML, een codegebaseerde manier om de pipeline te definiëren.
• Sla de pipeline op en voer hem uit om te zien of alles correct werkt.

Kiezen tussen YAML en Classic Editor

Azure Pipelines biedt twee manieren om je pipelines te definiëren:

• YAML-pipelines: Een codegebaseerde manier om je pipeline te beschrijven. Ze worden gedefinieerd in een .yaml- of .yml-bestand in je bronrepository, wat versiebeheer en betere samenwerking mogelijk maakt.
• Classic Editor: Classic Editor is een gebruiksvriendelijke, visuele drag-and-drop-interface die minder flexibel is voor complexe scenario's.

Uit mijn ervaring bieden YAML-pipelines meer flexibiliteit en zijn ze beter voor teams die Infrastructure as Code (IaC) toepassen. Maar de Classic Editor is perfect voor nieuwkomers die liever visueel werken. 

Voor schaalbaarheid op de lange termijn worden YAML-pipelines echter aanbevolen boven Classic Editor.

Bouwen met Azure Pipelines

Laten we nu bekijken hoe we kunnen bouwen met Azure Pipelines. 

In deze sectie specificeren we de stappen die Azure Pipelines neemt om je code te bouwen, zoals afhankelijkheden installeren, compileren en tests uitvoeren. We drukken deze stappen uit in een configuratiebestand in onze broncode-repo met YAML, een eenvoudige, goed leesbare manier om stappen in een recept te beschrijven.

YAML-pipelinesyntaxis

Hier is een eenvoudig voorbeeld van een YAML-pipeline:

# This section defines the trigger(s) for the pipeline.
# 'main' specifies that the pipeline will run whenever changes are pushed to the 'main' branch.
trigger:
- main  # automatically triggers this pipeline when changes are made to the 'main' branch.

# This defines the pool where the pipeline will run.
# 'ubuntu-latest' specifies the virtual machine image for executing tasks.
pool:
  vmImage: 'ubuntu-latest'  # This uses the latest Ubuntu image provided by Azure DevOps.

# Steps contain the individual tasks or actions that the pipeline will execute.
steps:
- script: echo Hello, world!  # A script task to run shell commands. This one prints "Hello, world!".
  displayName: 'Run my first pipeline script'  # A friendly name for this step, making it easier to identify in the pipeline logs.

Laten we de code stap voor stap doornemen:

• trigger: Geeft de branch aan die de pipeline triggert (bijv. main).
• pool: Definieert de buildagent (bijv. ubuntu-latest).
• steps: Lijst met taken die worden uitgevoerd, zoals afhankelijkheden installeren en een buildscript draaien.

Buildstappen configureren

Om buildstappen toe te voegen aan je YAML-pipeline, definieer je het ‘script’ onder de sectie ‘steps’.

Voor een eenvoudige Node.js-applicatie bevat ons azure-pipelines.yml-bestand hieronder bijvoorbeeld code die Azure DevOps automatisch heeft aangemaakt.

# Node.js
# Build a general Node.js project with npm.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: NodeTool@0
  inputs:
    versionSpec: '20.x'
  displayName: 'Install Node.js'

- script: |
    npm install
    npm run build
  displayName: 'npm install and build'

Laten we naar de build-steps in de YAML-pipeline hierboven kijken: 

1. Node.js installeren: Gebruik de taak NodeTool@0 om de Node.js-versie te specificeren. 
2. Afhankelijkheden installeren: Voer npm install uit om projectafhankelijkheden te installeren. 
3. Code compileren (project builden): Voer npm run build uit om de code te compileren. 

De pipeline uitvoeren

Onze pipeline kan handmatig worden getriggerd of automatisch draaien wanneer er gebeurtenissen zoals pushes naar een branch plaatsvinden.

• Handmatige trigger: Klik op Run Pipeline in de Azure DevOps-interface om de pipeline handmatig te starten.

• Automatische trigger: Stel triggers in op basis van repository-evenementen zodat pushes naar de main-branch de pipeline automatisch starten. Hier is een voorbeeld:

trigger:
- main

Na het uitvoeren van je pipeline kun je logs bekijken en problemen oplossen.

Ga om logs te openen naar de samenvatting van je pipeline-run en selecteer de specifieke job of taak. Hierdoor worden de logs voor die stap weergegeven; net als op de afbeelding hieronder kun je elke job (Build, Push of Update) kiezen om de ruwe logs te bekijken.

Voor het oplossen van veelvoorkomende problemen kun je je pipeline controleren op zaken als time-outs, resourcebeperkingen of misconfiguraties.

Tests toevoegen aan je pipeline

Je voegt tests toe aan je pipeline om de codekwaliteit te waarborgen en problemen vroeg in de ontwikkeling te ontdekken. In Azure Pipelines kun je unit-, integratie- of andere tests integreren door stappen in je pipelineconfiguratie toe te voegen.

Teststappen configureren

Neem teststappen op in je pipeline om de codekwaliteit te garanderen. Je kunt populaire frameworks gebruiken zoals Jest, Mocha of NUnit. Hieronder staat bijvoorbeeld hoe je unit-tests met Jest toevoegt:

- script: |
    npm test
  displayName: 'Run unit tests with Jest'

Testresultaten bekijken

Azure Pipelines heeft ingebouwde testrapportage. Je kunt het publiceren van testresultaten instellen voor eenvoudiger bijhouden en testresultaten bekijken in de pipelinelogs. Zo doe je dat:

• Navigeer eerst naar Builds > Test Results.
• Gebruik om testresultaten te publiceren de taak PublishTestResults@2 om resultaten weer te geven. Dit maakt het algemene bijhouden eenvoudiger. Bijvoorbeeld:

- task: PublishTestResults@2
  inputs:
    testResultsFiles: '**/test-results.xml'
    testRunTitle: 'Unit Tests'

Deployen met Azure Pipelines

In de deploymentstappen in je Azure-pipeline-YAML-bestand kun je je applicatie automatisch naar verschillende omgevingen deployen, zoals testing, staging en productie. In deze sectie bekijken we een paar manieren om te deployen met Azure Pipelines.

Deployen naar Azure Web Apps

Azure Web Apps is een service in de Azure-portal waarmee je webapplicaties op schaal kunt ontwikkelen, deployen en beheren. 

Om naar Azure Web Apps te deployen, moet je de twee services koppelen. Zo doe je dat:

• Ga linksonder in je project naar Project Settings en klik op Service Connections onder de Pipelines sectie. 

• Klik op New Service Connection en kies Azure Resource Manager. 

• Authenticeer met je Azure-account.
• Deploy naar Azure App Service:
  • Ga terug naar je Pipelines en configureer je pipeline.
  • Voeg in je pipeline een taak toe om naar Azure te deployen.
  • Specificeer de resourcegroep en servicedetails. 

Hier is een voorbeeld van een YAML-deploymentpipeline voor een simpele Node.js-app naar Azure App Service:

# Define the task for deploying to an Azure Web App
- task: AzureWebApp@1
  inputs:
    # This specifies your Azure subscription service connection
    azureSubscription: 'your-azure-subscription'
    # This specifies the name of your web app
    appName: 'your-app-name'
    # This specifies the location of the app package or files to be deployed
    package: '$(Build.ArtifactStagingDirectory)'

Laten we de code hierboven opsplitsen, zodat je hem kunt aanpassen aan jouw use-case:

• Vervang your-azure-subscription door de naam van de serviceverbinding die toegang geeft tot je Azure-subscriptie.
• Vervang your-app-name door de daadwerkelijke naam van je webapp in Azure. 
• Vervang $(Build.ArtifactStagingDirectory) door de directory waar het webapppakket of de bestanden voor deployment staan. $(Build.ArtifactStagingDirectory) — Deze variabele verwijst naar de map waar je buildartefacten (je appbestanden) staan nadat ze zijn gebouwd.

Continue deployment (CD) instellen

Zodra alles in onze code alle tests en checks doorstaat, is de volgende stap het instellen van continue deployment. Volg de onderstaande stappen.

Deploymentmodel voor Azure-releasepipeline (Bron: Microsoft)

• Maak een releasepipeline:
• Ga naar Pipelines > Releases en klik op New Pipeline.

• Selecteer de template Azure App Service Deployment.

• Omgevingen configureren:
• Voeg de omgevingen Dev, Staging, QA en Production toe en configureer ze, waar je applicatie moet worden gedeployed.

• Koppel het artefact van je buildpipeline als bron voor de releasepipeline door Add an artifact te selecteren.

• Approvals en gates configureren:
• Het instellen van pre-deployment approvals voor gevoelige omgevingen, zoals productie, is noodzakelijk. Bijvoorbeeld: een teamleider moet de release goedkeuren. Je kunt ook gates toevoegen, zoals geautomatiseerde tests of monitoringchecks, om te garanderen dat de deployment aan kwaliteitsnormen voldoet.

Uit mijn ervaring is deze fase cruciaal om stabiliteit te behouden in veeleisende ontwikkelomgevingen. Approvals en gates bieden controle en zorgen dat alleen hoogwaardige code productie bereikt.

Deployen naar Kubernetes

Kubernetes maakt het eenvoudig om betrouwbare en schaalbare gecontaineriseerde applicaties te draaien. Met Azure Kubernetes Service (AKS) krijg je een beheerde omgeving die deployment en operatie vereenvoudigt. In deze sectie laat ik zien hoe je met Azure Pipelines naar AKS kunt deployen.

Je AKS-cluster voorbereiden

Je kunt een AKS-cluster maken via de Azure-portal of CLI. Hier is een basis Bash-CLI-opdracht om een cluster te provisionen:

az aks create \
  --resource-group <ResourceGroupName> \
  --name <AKSClusterName> \
  --node-count 3 \
  --enable-addons monitoring \
  --generate-ssh-keys

Laten we de opdracht hierboven doornemen:

• --resource-group: Dit geeft de Azure-resourcegroep aan waarin het AKS-cluster wordt gemaakt.
• --name: Dit is de naam van je AKS-cluster.
• --node-count: Hiermee stel je het aantal nodes in het cluster in (bijv. 3 in dit voorbeeld).
• --enable-addons monitoring: Hiermee worden monitoring en analytics mogelijk met Azure Monitor for Containers.
• --generate-ssh-keys: Hiermee worden automatisch SSH-sleutels gegenereerd voor veilige node-toegang als ze niet zijn opgegeven.

Vergeet niet <ResourceGroupName> en <AKSClusterName> te vervangen door je daadwerkelijke resourcegroep- en clusternamen.

Na het opzetten van je AKS-cluster moet kubectl worden geconfigureerd. Dit zorgt ervoor dat je pipelineagent of lokale computer met kubectl met het cluster kan communiceren.

Je kunt je Azure-taken versnellen met commandline-tools—deze Azure CLI-cheat sheet is een handige referentie.

Maak een deployment-YAML-bestand 

Laten we als voorbeeld een basis deployment-YAML-bestand nemen voor het deployen van een Docker-image naar Kubernetes:

# This defines the API version and the kind of Kubernetes resource we are creating.
# 'apps/v1' is the API version, and 'Deployment' is the resource type.
apiVersion: apps/v1
kind: Deployment

# Metadata contains information to identify the resource uniquely.
# 'name' specifies the name of the Deployment.
metadata:
  name: my-app  # Name of the Deployment, used for identification.

# "spec" specifies the intended deployment state.
spec:
  # Number of replicas/pods we want for this Deployment.
  replicas: 3  # Ensures high availability by running three app replicas.

  # Selector is used to define the labels that this Deployment will manage.
  selector:
    matchLabels:
      app: my-app  # This ensures that only Pods with the label 'app: my-app' are managed by this Deployment.

  # Template specifies the blueprint for the pods created by the Deployment.
  template:
    metadata:
      labels:
        app: my-app  # Labels for the Pods, matching the selector above.

    # A specification for the containers of the Pods.
    spec:
      containers:
      - name: my-app  # Name of the container. This is useful for linking to the container in logs, etc.
        image: mycontainerregistry.azurecr.io/my-app:latest  # Pull the container image you will call from your container registry.
        ports:
        - containerPort: 80  # The container listens on port 80.

Deployen met Azure Pipelines

Neem in je YAML-pipeline een taak op om naar AKS te deployen.

# This defines a task for deploying Kubernetes manifests within an Azure DevOps pipeline.
- task: KubernetesManifest@0  # Task type for working with Kubernetes manifest files.
  inputs:
    # This configures what to do with the Kubernetes manifest files.
    action: 'deploy'  # 'deploy' action ensures the Kubernetes manifests are applied to the cluster.

    # This defines the namespace where the Kubernetes resources will be deployed.
    namespace: 'default'  # 'default' is the namespace for deploying resources. Change if needed.

    # All this does is point to the manifest files that define the desired state of your Kubernetes resources.
    manifests: '$(Build.ArtifactStagingDirectory)/manifests/*.yaml'
    # The 'manifests' variable points to the location of all the YAML files (e.g., Deployment, Service, etc.) that will be applied during the deployment.

    # To access private container registry images, use the image pull secret.
    imagePullSecrets: 'my-registry-secret'
    # This instructs Kubernetes on which secret to use when pulling images from a private container registry.
    # Ensure that 'my-registry-secret' exists in the namespace before the deploy

Commit en push het YAML-bestand om de deployment te triggeren.

AKS vereenvoudigt containerorkestratie, waardoor schalen, updates en rollbacks makkelijker te beheren zijn. Uit mijn ervaring is het onmisbaar voor moderne cloud-native applicaties.