Heb je ooit het gevoel dat het inrichten van je DevOps-omgeving voelt als proberen een IKEA-kast zonder handleiding in elkaar te zetten? Dan ben je hier aan het juiste adres. Laten we de technische blokkendoos samen uitpakken en iets bouwen wat soepel werkt. Geen droge stappenlijst, maar een lekker verhaal dat je direct aan de slag zet.

Bij Azure DevOps draait alles om samenwerken en automatiseren. Zie het als de dirigent van jouw project. Het brengt je code, je team en je deployment-processen samen in perfecte harmonie. Maar voordat je begint, heb je een paar dingen nodig:

1. Een Azure DevOps-account: Maak een project aan—noem het iets tofs zoals NextBigThing.
2. Git Repositories: Maak een nieuwe repository aan binnen je DevOps-project, hier wordt je code opgeslagen.

En nu komt het leuke gedeelte: koppel alles aan Visual Studio Code.

Visual Studio Code: Het Zwitsers zakmes voor developers

VS Code is dé plek waar ideeën werkelijkheid worden. Maar voordat je daar aan de slag kunt, moet je wat voorbereiden.

Wat je nodig hebt:

• Visual Studio Code: Download de laatste versie  hier.
• Azure Repos Extension: Download hier de laatste versie.
• Git: Zorg dat Git lokaal op je computer staat.  Download het hier.
• Azure CLI: Azure CLI is onmisbaar,  download Azure CLI.

De connectie leggen: VS Code en Azure DevOps

Nu je de benodigdheden hebt, is het tijd om alles samen te brengen. Denk eraan: we bouwen iets moois. Open je terminal in Visual Studio Code en voer het volgende uit om je repository te initialiseren:

git init

Voeg vervolgens je Azure DevOps-repository toe als remote. Hier komt die Azure Repos-extensie van pas. Koppel de repository door op Clone Repository te klikken en je Azure DevOps-project te selecteren.

Je hebt nu een lokaal en een remote repository, perfect gesynchroniseerd. Schrijf wat code, commit je wijzigingen, en push ze naar Azure DevOps met een simpele:

VS Code maakt dit nóg makkelijker met ingebouwde Git-controls—gewoon klikken en gaan!

Pipelines: Automatiseren als een pro

Nu je repo staat, gaan we je DevOps echt laten shinen. Pipelines zijn het hart van elke Azure DevOps setup. Stel je een superbriljante deployment-pijpleiding voor die je code automatisch uitrolt naar een Azure-resource. Met YAML kun je deze magie coderen.

Hier een kort voorbeeld voor Terraform:

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- script: |
    terraform init
    terraform plan
    terraform apply -auto-approve
  displayName: 'Deploy Terraform'

Klinkt fancy? Dat is het ook. Maar het geeft je totale controle over wat, waar, en hoe je code live gaat.

Virtual Machines en Key Vault: De kroon op je werk

Je hebt nu een DevOps-pipeline. Tijd om echt iets cools te deployen, zoals een virtuele machine met logingegevens die veilig in een Key Vault worden opgeslagen.

Voorbeeld Terraform-config:

resource "azurerm_virtual_machine" "vm_example" {
  name                  = "myVM"
  location              = azurerm_resource_group.example.location
  resource_group_name   = azurerm_resource_group.example.name
  vm_size               = "Standard_DS1_v2"

  os_profile {
    computer_name  = "myVM"
    admin_username = "azureuser"
    admin_password = azurerm_key_vault_secret.vm_password.value
  }
}

resource "azurerm_key_vault" "example" {
  name                = "myKeyVault"
  resource_group_name = azurerm_resource_group.example.name
  location            = azurerm_resource_group.example.location
}

resource "azurerm_key_vault_secret" "vm_password" {
  name         = "vmAdminPassword"
  value        = "SuperSecurePassword123!"
  key_vault_id = azurerm_key_vault.example.id
}

Het is veiliger als je het wachtwoordt automatisch laat genereren. Dat kan met bijvoorbeeld de volgende code:

resource "random_password" "admin_password" {
  length           = 16
  special          = true
  override_special = "!#$%&*()-_=+[]{}<>?"
}

Dit wachtwoord wordt veilig gegenereerd en is nooit zichtbaar in je Terraform-bestanden. Het gegenereerde wachtwoord slaan we direct op in Azure Key Vault. Dit maakt het toegankelijk voor andere resources zonder dat je het wachtwoord in je code hoeft te bewaren, dat kan met de volgende code:

resource "azurerm_key_vault_secret" "vm_admin_password" {
  name         = "vmAdminPassword"
  value        = random_password.admin_password.result
  key_vault_id = azurerm_key_vault.example.id
}

Het wachtwoord wordt nu veilig opgeslagen in de Key Vault, waar alleen geautoriseerde resources of gebruikers toegang toe hebben. In plaats van het wachtwoord direct in je code te zetten, haal je het op uit de Key Vault op het moment dat het nodig is.

resource "azurerm_virtual_machine" "example" {
  name                  = "example-vm"
  location              = azurerm_resource_group.example.location
  resource_group_name   = azurerm_resource_group.example.name
  vm_size               = "Standard_DS1_v2"

  os_profile {
    computer_name  = "example-vm"
    admin_username = "azureuser"
    admin_password = data.azurerm_key_vault_secret.vm_admin_password.value
  }

  ...

  lifecycle {
    ignore_changes = [admin_password]
  }
}

data "azurerm_key_vault_secret" "vm_admin_password" {
  name         = "vmAdminPassword"
  key_vault_id = azurerm_key_vault.example.id
}

Met deze configuratie wordt het wachtwoord veilig uit de Key Vault opgehaald zonder dat het in je Terraform-bestanden voorkomt.

Deploy dit via je YAML-pipeline en laat Azure het zware werk doen. Jouw VM staat binnen een paar minuten live.

Hulp nodig? Wij fixen het!

Het klinkt misschien als een hoop gedoe, maar met de juiste setup en tools wordt Azure DevOps een feestje. Heb je ergens hulp bij nodig? Of wil je gewoon dat alles werkt zonder hoofdpijn? Neem contact met ons op, en wij regelen het voor je.