Ik ben bezig met certificering voor AZ-204 van Azure, waarbij ik de lessen/uitleg/instructies van Azure zelf volg via deze flow: link. Ik was bij blok 4 begonnen: link, daarna heb ik blok 1 uitgevoerd: link, daarna blok 2: link en daarna blok 3: link. Het wordt tijd om het 5e en laatste blok aan te pakken, Manage resources in Azure: link.
Op 4 augustus ben ik begonnen met het boek: link, vandaag op 4 december heb ik dat dus uit, de pluralcourse video's bekeken en alle blokken van Azure zelf (zelfstudie) bijna behaald, alleen deze nog. Het laat zien dat met een studie bezig gaan naast je normale werk en andere bezigheden er in hakt, bijna 4 maanden later ben je zover. Dat komt omdat je 2 avonden (soms 3 avonden in de week) 3 uurtjes hebt om ermee aan de slag te gaan. De extra tijd zit natuurlijk ook in het uitwerken en samenvatten van de stappen op dit Techblog, dat kost extra tijd. Maar het zorgt er wel voor dat de stof (langer) blijft hangen en iets wat je 4 maanden geleden hebt gedaan zit niet meer heel recent in je geheugen: dat kun je dus terug lezen.
Maar we zijn er nog niet. Als ik deze blokken afgerond heb, ga ik afvinken op de lijst met specs voor het examen wat behandeld is. En volgens mij blijven er dan punten over die niet behandeld zijn: die moet je zelf nog onderzoeken. Dus hoewel mijn doel was om in 2021 het examen te behalen, hou ik er eerst maar rekening mee dat het januari 2022 wordt. Dat maakt niet uit, beter wat later en "zekerder van je zaak zijn", dan dat je een datum prikt en zelf al weet: ik zou hier eigenlijk nog (veel) meer voor moeten doen.
Tijd voor het eerste blok, Align requirements with cloud types and service models in Azure: link.
Je hebt verschillende type "clouds", de public cloud, de private cloud en de "hybride" cloud, ieder met zijn eigen voor- en nadelen.
De public cloud is het meest voorkomende type. De cloud-provider heeft het beheer en bepaald waar jouw data staat. De gegevens zijn online te bereiken. Voordelen hiervan zijn dat je alleen voor het gebruik betaalt, je hoeft geen hardware in te kopen, de automatisering: via scripts, portal, andere automatisering kun je zo een nieuwe omgeving opstarten, geografische verspreiding: zitten je klanten in China, dan kun je daar de servers laten draaien zonder daar zelf een data-center te hoeven (laten) bouwen en geen hardware onderhoud: je hoeft niet na x jaar de hardware te vervangen omdat deze verouderd is.
Bij een private cloud is de data alleen beschikbaar voor je eigen organisatie, bijvoorbeeld via Kubernetes clusters of Azure Stack. Het hoeft geen on-premise te zijn, het kan ook in een datacenter draaien waar je alleen zelf via VPN bij kunt komen. Voordelen van deze oplossing: bestaande omgevingen: je hebt een MS DOS 5.0 omgeving nodig, iets wat een online provider niet meer biedt, legacy applicaties: software die alleen hier kan draaien, data soevereniteit en security: je bent een bank of overheidsinstantie en je data moet aan bepaalde eisen voldoen, certificering/andere regels: je datacenter moet aan bepaalde eisen voldoen.
Een hybride cloud is een combinatie van beiden. Zo kun je een private cloud hebben, maar als de belasting heel hoog wordt kun je een soort "overloop" hebben naar een public cloud om het verkeer aan te kunnen. Redenen waarom je dit type cloud zou gebruiken: eisen dat je bepaalde hardware of bestaand OS gebruikt, wetten/regels bepalen dat je data op een fysieke locatie opgeslagen moet worden, unieke omgeving: er geen cloud-alternatief beschikbaar en migratie: verplaats in de loop van de tijd je workloads naar de cloud.
Je hebt in de cloud verschillende modellen, Iaas (infrastructure as a service), PaaS (platform as a service), SaaS (software as a service).
Infrastructure as a Service
Als je eigen software wilt draaien, verschillende versies van zaken wilt testen, is dit je keuze.
Platform as a Service
Als je een website in PHP wilt laten draaien en je niet bezig wilt houden met webservers, onderliggende systemen installeren, dan is PaaS je keuze.
Software as a Service
Staat voor online software, zoals e-mail, agenda's, Office 365.
Dit zijn zaken die ook in de Fundamentals naar voren gekomen zijn, dus door naar het volgende blok, Control Azure services with the CLI: link.
De case bij dit blok is dat je in een bedrijf werkt waar meerdere developers via de portal zaken aanmaken en dit anders inrichten, dat moet op een zelfde manier. We gaan dus zaken inrichten zodat dit met de CLI uit te voeren is. Deze kun je draaien op Mac (met Homebrew), Windows en Linux (apt-get / yum / zypper). Het is de command-line waarin je zaken als dit doet:
// virtuele machine herstarten
az vm restart -g MyResourceGroup -n MyVm
// installatie
// LINUX
AZ_REPO=$(lsb_release -cs)
echo "deb [arch=amd64] https://packages.microsoft.com/repos/azure-cli/ $AZ_REPO main" | \
sudo tee /etc/apt/sources.list.d/azure-cli.list
curl https://packages.microsoft.com/keys/microsoft.asc | sudo apt-key add -
sudo apt-get install apt-transport-https
sudo apt-get update && sudo apt-get install azure-cli
az --version
// MAC
brew update
brew install azure-cli
az --version
// WINDOWS
https://aka.ms/installazurecliwindows
Na installatie krijgen we een aantal voorbeelden. Zo kun je met az find <keyword> meer informatie krijgen over iets wat je zoekt. Of door achter je commando --help te plaatsen, vaak krijg je dan ook meer informatie over het commando daarvoor. Met az login kun je inloggen en je acties doen. Werkt dat niet (goed), dan moet je vaak een code nog invoeren die je kunt opvragen via deze link.
az group is de actie waar je vaak mee begint, az group create --name <name> --location <location> voor het aanmaken van een resource-group, az group list voor een overzicht.
We gaan via de Azure Cloud Shell zaken aanmaken:
export RESOURCE_GROUP=[jouw resource groep naam]
export AZURE_REGION=centralus
export AZURE_APP_PLAN=popupappplan-$RANDOM
export AZURE_WEB_APP=popupwebapp-$RANDOM
// bekijk de aangemaakte groep in ons "learn-account"
az group list --output table
// mocht je later meerdere groepen hebben, dan kun je een query gebruiken:
az group list --query "[?name == '$RESOURCE_GROUP']"
// we gaan een service plan aanmaken:
az appservice plan create --name $AZURE_APP_PLAN --resource-group $RESOURCE_GROUP --location $AZURE_REGION --sku FREE
// controle of het gelukt is:
az appservice plan list --output table
// web app maken:
az webapp create --name $AZURE_WEB_APP --resource-group $RESOURCE_GROUP --plan $AZURE_APP_PLAN
// en natuurlijk controleren:
az webapp list --output table
// vanuit Github je content halen:
az webapp deployment source config --name $AZURE_WEB_APP --resource-group $RESOURCE_GROUP --repo-url "https://github.com/Azure-Samples/php-docs-hello-world" --branch master --manual-integration
We zagen in bovenstaande dat je soms filtert. Daarvoor gebruikt Azure JMESPath, een standaard voor JSON. Je kunt hier meer daarover lezen: link.
Door met het volgende blok, Automate Azure tasks using scripts with PowerShell: link.
De voorbeeld-case is waarbij meerdere VM's worden opgezet met databases en waarbij een bug optreedt. Je wilt scenario's testen en dat willen we automatiseren (want dat ga/wil je echt niet handmatig doen).
Zo heb je in Azure Powershell dit commando om een Virtual Machine aan te maken:
New-AzVm `
-ResourceGroupName "CrmTestingResourceGroup" `
-Name "CrmUnitTests" `
-Image "UbuntuLTS"
...
Als we het over de Poweshell hebben, dan hebben we het eigenlijk over twee onderdelen. De "basic" powershell, waarmee je commando's uit kunt voeren. En de Azure AZ PowerShell Module, waardoor je de az-commando's kunt gebruiken.
Om te werken met de Azure AZ PowerShell Module wordt aangeraden om versie 7.0.6 LTS of 7.1.3 of hoger te installeren.
// huidige versie checken:
$PSVersionTable.PSVersion
pwsh --ver
// WINDOWS
// ik heb versie 5.1 - upgraden dus!
// ik ga voor de LTS:
https://aka.ms/powershell-release?tag=lts
// installeer ook de SDK tools:
dotnet tool install --global PowerShell
// MAC
brew install --cask powershell
pwsh
// Linux
curl https://packages.microsoft.com/keys/microsoft.asc | sudo apt-key add -
sudo curl -o /etc/apt/sources.list.d/microsoft.list https://packages.microsoft.com/config/ubuntu/18.04/prod.list
sudo apt-get update
sudo apt-get install -y powershell
pwsh
Installatie Windows details: link.
Mac, Homebrew details: link.
We gaan door met cmdlets, uitgesproken als "command-lets". Het is een commando welke 1 feature uitvoert/aanpast. Zo heb je de command-lets Get-Process, Format-Table, en Start-Service. Een handige cmdlet is de Get-Help die je info geeft over andere cmdlets. Bijvoorbeeeld Get-Help -Name Get-ChildItem -Detailed
Vervolg is modules. Cmdlets worden verscheept in modules. Je hebt dan een DLL waarmee die cmdlets uitgevoerd kunnen worden. Door Get-Module uit te voeren kun je zien welke modules er op jouw systeem staan.
De Az Powershell Module (Az) geeft je de mogelijkheid om met Azure te werken, code staat op Github: link. De site meldt nog dat sommige commando's een -AzureRM gebruiken, legacy van AzureRM Powershell. Deze functionaliteit werkt vanaf 29 februari 2024 niet meer, dus stap alvast over naar de beschikbare (wel werkende) alternatieven. En dat kun je met behulp van de Quickstart Guide: link.
// installatie van de module:
Install-Module -Name Az -Scope CurrentUser -Repository PSGallery
// foutmeldingen over rechten:
Get-ExecutionPolicy
// geeft die Restricted, dan aanpassen naar RemoteSigned
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
// module updaten:
Update-Module -Name Az
// Linux / Mac
pwsh
Install-Module -Name Az -Scope CurrentUser -Repository PSGallery -Force
We krijgen vervolgens een aantal commando's die je vaker zult gebruiken:
// connectie maken:
Connect-AzAccount
// controle in welk account en abo je zit:Get-AzContext
Get-AzSubscriptionSet-AzContext -Subscription '00000000-0000-0000-0000-000000000000'
// list van resourcegroups tonen
Get-AzResourceGroup
// resourcegroup aanmaken en daarna controle
New-AzResourceGroup -Name <name> -Location <location>
Get-AzResource
// VM aanmaken
New-AzVm
-ResourceGroupName <resource group name>
-Name <machine name>
-Credential <credentials object>
-Location <location>
-Image <image name>
// combi met Get-Credential
New-AzVM -Name MyVm -ResourceGroupName ExerciseResources -Credential (Get-Credential) ...
// VM opvragen + aanpassen
$ResourceGroupName = "ExerciseResources"
$vm = Get-AzVM -Name MyVM -ResourceGroupName $ResourceGroupName
$vm.HardwareProfile.vmSize = "Standard_DS3_v2"Update-AzVM -ResourceGroupName $ResourceGroupName -VM $vm
We gaan vervolgens een VM aanmaken, met behulp van de Azure Cloud Shell. Dat is een Linux-variant, dus je moet username en password ingeven. Meer info hier: link. Een wachtwoord moet 12 - 123 tekens lang zijn en aan 3 van de 4 eisen voldoen:
- moet kleine letters bevatten
- moet hoofdletters bevatten
- moet cijfers bevatten
- moet een speciaal karakter bevatten (volgens de site regex: [\W_]).
New-AzVm -ResourceGroupName naam-resource-group -Name "testvm-eus-01" -Credential (Get-Credential) -Location "East US" -Image UbuntuLTS -OpenPorts 22
$vm = (Get-AzVM -Name "testvm-eus-01" -ResourceGroupName learn-589d4f29-c901-499e-bcee-47b9050984fa)
$vm
$vm.HardwareProfile
$vm | Get-AzPublicIpAddressssh gebruikersnaam@205.22.16.5
// stoppen
Stop-AzVM -Name $vm.Name -ResourceGroup $vm.ResourceGroupName
// delete
Remove-AzVM -Name $vm.Name -ResourceGroup $vm.ResourceGroupName
// controle van resources:
Get-AzResource -ResourceGroupName $vm.ResourceGroupName | Format-Table
// je ziet dan zaken die er allemaal nog zijn:
Microsoft.Compute/disks
Microsoft.Network/networkInterfaces
Microsoft.Network/networkSecurityGroups
Microsoft.Network/publicIPAddresses
Microsoft.Network/virtualNetworks
// network interface verwijderen
$vm | Remove-AzNetworkInterface –Force
// OS disks en storage account verwijderen
Get-AzDisk -ResourceGroupName $vm.ResourceGroupName -DiskName $vm.StorageProfile.OSDisk.Name | Remove-AzDisk -Force
// virtual network verwijderen
Get-AzVirtualNetwork -ResourceGroup $vm.ResourceGroupName | Remove-AzVirtualNetwork -Force
// network security group (NSG) verwijderen
Get-AzNetworkSecurityGroup -ResourceGroup $vm.ResourceGroupName | Remove-AzNetworkSecurityGroup -Force
// en het publieke ip-adres
Get-AzPublicIpAddress -ResourceGroup $vm.ResourceGroupName | Remove-AzPublicIpAddress -Force
Het volgende deel gaat over het maken en opslaan van scripts in powershell. Dit zijn .ps1 bestanden.
Door naar het volgende blok, Control and organize Azure resources with Azure Resource Manager: link.
De voorbeeld-case waar we mee aan de slag gaan is een bedrijf wat allemaal afdelingen heeft, die ieder hun eigen ding gedaan heeft. Wij moeten de boel met Azure op orde gaan brengen.
We beginnen met een resource-groep. Hier plaats je zaken in die bij elkaar horen. Deze kun je op basis van rol (RBAC) beheren. Deze resource-groepen kun je op meerdere manieren aanmaken: Azure portal, Azure PowerShell, Azure CLI, Templates, Azure SDKs (zoals .NET, Java).
Hoe kun je zorgen dat de boel "goed georganiseerd" is? Onder andere door naamgeving. waar wordt het voor gebruikt-type van de resources-rg zou je kunnen volgen.
Het indelen van de resource-groep(en) kan op meerdere manieren. Je kunt dezelfde resources in 1 groep zetten. Of je gaat per afdeling werken. Of je verdeelt het per omgeving (dev/test/acc/prod). Het is de vraag welke methode op jou van toepassing is.
Ga je organiseren op basis van autorisatie? Mogen db-admins alleen de SQL-databases beheren? Dan is het makkelijk dat je die allemaal in 1 resource-groep hebt. Dan kun je ze daar toegang op geven en op alle andere onderdelen de toegang weigeren.
Of organiseer je op basis van lifecycle? Heb je een dev-omgeving met 20 verschillende resources, maar je weet dat die over 2 weken weer verwijderd moet worden? Plaats ze allemaal in 1 resource-groep, als je die verwijderd, worden alle onderdelen ook automatisch verwijderd.
Of organiseer je het op basis van facturatie? Moet elke afdeling zijn eigen resources afrekenen? Dan is het beter om resources per afdeling in een resource-groep te plaatsen.
Nadat je deze scheiding hebt aangebracht ben je misschien toch niet helemaal tevreden. Want iets kan meerdere eigenschappen hebben, even los van de verdeling via resource-groep. Daarvoor kun je gebruik maken van tagging. Dat zijn key-value paren waarmee je extra eigenschappen toe kunt voegen. Voorbeelden hiervan zijn:
- afdeling (financiën, marketing, etc.)
- omgeving (prod, dev, test)
- kostenplaats (boekhoudkundige koppeling)
- life-cycle en automatisering (bijvoorbeeld voor het afsluiten en opstarten van Virtuele Machines)
Een resource kan 50 tags bevatten. Een key-waarde kan maximaal 512 tekens bevatten (behalve storage-accounts, daar zit de limiet op 128 tekens). De waardes kunnen maximaal 256 karakters. Classic resources ondersteunen geen tags en ook sommige andere resources ondersteunen geen tags.
Je kunt tags aanpassen via de Azure portal, Azure CLI, Azure PowerShell, Resource Manager templates en REST API.
Voorbeeld:
az resource tag --tags Department=Finance \
--resource-group msftlearn-core-infrastructure-rg \
--name msftlearn-vnet1 \
--resource-type "Microsoft.Network/virtualNetworks"
De site toont nog even hoe je via tags een automation-job kunt laten detecteren dat iets afgesloten of opgestart moet worden: shutdown:6PM en startup:7AM.
Als je standaarden af wilt dwingen, dan ga je gebruik maken van Azure Policies. De site geeft het voorbeeld voor de policy dat een resource altijd de tag "department" moet hebben, zodat duidelijk is welke afdeling een resource in gebruik heeft.
Naast het aanmaken van de policy in de Portal voeg je het onderstaande script toe:
{
"mode": "Indexed",
"policyRule": {
"if": {
"field": "[concat('tags[', parameters('tagName'), ']')]",
"exists": "false"
},
"then": {
"effect": "deny"
}
},
"parameters": {
"tagName": {
"type": "String",
"metadata": {
"displayName": "Tag Name",
"description": "Name of the tag, such as 'environment'"
}
}
}
}
Je ziet dat een parameter nodig is, die voeg je in de Policy toe, daar vul je dus de naam "tagName" en waarde "department" in.
Vervolgens het afschermen met behulp van rollen. De site geeft deze voorbeelden:
- je kunt een gebruiker de rechten geven om VM's te beheren in een abonnement en een andere gebruiker om virtuele netwerken te beheren.
- je kunt een database administrator (DBA) groep de rechten geven om SQL databases in een abonnement te beheren.
- je kunt een gebruiker de rechten geven om alle resources in een resource-groep aan te passen.
- je kunt een applicatie rechten geven om toegang te krijgen tot alle resources in een resource-groep.
En aanvullende beveiliging: resource-locks. Je hebt 2 smaken: Delete en Read-Only. Bij Read-Only kun je alleen lezen, je kunt dus niet verwijderen, aanpassen (dus een foutieve tag kun je ook niet aanpassen). Bij Delete kun je een resource niet verwijderen, maar wel zaken aanpassen.
Tijd voor het laatste blok, Move Azure resources to another resource group: link.
Het voorbeeld wat we krijgen is dat mensen development-resources in een resource-groep hebben geplaatst waar ook productie-resources in staan. En iemand heeft een resource-groep verwijderd omdat hij/zij dacht dat er alleen development-zaken in stonden, maar dat bevatte dus ook productie-resources... Tijd om de development-resources in een development-resource-groep te plaatsen.
Sommige zaken kunnen verplaatst worden, maar sommige ook niet. Op deze pagina krijg je een volledig overzicht en kun je zien of het wel of niet kan/mag: link. Maar er zitten soms wel addertjes onder het gras. Zoals het verplaatsen van een web-app wel kan, kunnen de 3rd party SSL certificaten niet meegenomen worden. Een VM kan wel verplaatst worden, maar de gekoppelde zaken moeten dan ook mee. Als je certificaten voor een VM in een key-vault staan, kun je niet switchen tussen abonnementen. VM Scale sets (standaard) of met een publiek IP kun je niet verplaatsen. Managed disks in availability zones kun je niet naar een ander abonnement verplaatsen.
Gelukkig kun je met een "test-commando'" voor een echte verplaatsing valideren of het goed zou moeten gaan. Dat doe je met:
az rest --method post --uri <enter the correct REST operation URI here>
Je hebt hiervoor deze informatie nodig:
- Je Azure subscription ID.
- De naam van de resource groep waar de resources nu in staan (en waar ze dus uit moeten)
- De resource ID van elke resource in je originele groep
- De resource ID van de doel resource groep, dus waar de boel heen moet
- Jouw account access token
// header
POST https://management.azure.com/subscriptions/<your-subscription-id>/resourceGroups/<your-source-group>/validateMoveResources?api-version=2019-05-10
Authorization: Bearer <your-access-token>
Content-type: application/json
// content
{
"resources": ["<your-resource-id-1>", "<your-resource-id-2>", "<your-resource-id-3>"],
"targetResourceGroup": "/subscriptions/<your-subscription-id>/resourceGroups/<your-target-group>"
}
// via de Azure CLI
az rest --method post \
--uri https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/<your-source-group>/validateMoveResources?api-version=2019-05-10 \
--body "{\"resources\": [\"<your-resource-id-1>\", \"<your-resource-id-2>\", \"<your-resource-id-3>\"], \"targetResourceGroup\": \"/subscriptions/<your-subscription-id>/resourceGroups/<your-target-group>\"}" \
--verbose
// validatie response:
Response Code: 202
cache-control: no-cache
pragma: no-cache
expires: -1
location: https://management.azure.com/subscriptions/<your-subscription-id>/operationresults/<your-operation-id>?api-version=2018-02-01
retry-after: 15
// je ziet hier de URL die je na 15 seconden via een GET moet aanroepen
GET <location-url>
Authorization: Bearer <your-access-token>
// via de CLI
az rest --method get --uri <location-url>
// response 204 indien succesvol, anders:
{"error":{"code":"ResourceMoveProviderValidationFailed","message":"<message>"...}}
Bovenstaande ging over het test-proces, nu komen de stappen om een daadwerkelijke verplaatsing door te voeren:
// via de CLI
// maak een resource groep
az group create --name <destination resource group name> --location <location name>
// vraag de resource op
yourResource=$(az resource show --resource-group <resource group name> --name <resource name> --resource-type <resource type> --query id --output tsv)
// voer de verplaatsing uit
az resource move --destination-group <destination resource group name> --ids $yourResource
// controle of verplaatsing gelukt is:
az resource list --resource-group <destination resource group name> --query [].type --output tsv | uniq
// via PowerShell
New-AzResourceGroup -Name <destination resource group name> -Location <location name>
$yourResource = Get-AzResource -ResourceGroupName <resource group name> -ResourceName <resource name>
Move-AzResource -DestinationResourceGroupName <destination resource group name> -ResourceId $yourResource.ResourceId
Get-AzResource -ResourceGroupName <destination resource group name> | ft
Inmiddels zijn we zaterdagavond, 23.36 uur. Alle blokken zijn nu afgerond. Nu is het een kwestie van afvinken wat allemaal behandeld is en wat ik zelf op moet gaan pakken. Maar goed, dat is materiaal voor een volgende blog-post!