Jouw Fabric capaciteit sneller geautomatiseerd uitrollen

Microsoft Fabric is een SaaS-oplossing. Dat betekent dat de infrastructuur al grotendeels door Microsoft wordt gefaciliteerd. Om gebruik te maken van Fabric is echter wel configuratie benodigd en dien je ook na te denken over hoe om te gaan met je OTAP (ontwikkel-test-acceptatie-productie) omgevingen. In deze blog nemen we je mee door een serie van scripts die samen de Fabric-capaciteit uitrollen. Dit doen we met een combinatie van YML, Powershell en Bicep-sjablonen. Bicep is een domein specifieke taal (DSL) die het proces van het implementeren van Azure-resources vereenvoudigt. Meer informatie vind je hier: Bicep documentation | Microsoft Learn

Serviceconnecties in Azure DevOps

Voor deze implementatie zijn serviceconnecties in Azure DevOps vereist. Zorg ervoor dat de benodigde serviceconnecties correct zijn ingesteld onder Projectinstellingen > Pipelines > Serviceconnecties. 
Deze serviceconnecties zorgen ervoor dat de resources veilig en correct kunnen communiceren tijdens de implementatie. Wij hebben de serviceconnecties ook “eigenaar” gemaakt van de subscripties. Afhankelijk van jouw eigen IT-beleid kan je die rechten afschalen/specifieker maken. 

Het proces bestaat uit drie hoofdelementen:

1. Het hoofd-YML-script: Dit script definieert de algemene structuur van de pipeline, inclusief de stadia (stages) voor de verschillende omgevingen (bijvoorbeeld ontwikkeling en test). Het maakt gebruik van variabelen en sjablonen om de taken (jobs) te definiëren.
2. Het implementatie-YML-script: Dit script wordt aangeroepen door het hoofd-YML-script en definieert de specifieke taken die het PowerShell-script aanroept. Hier worden ook de parameters voor de implementatie opgegeven.
3. Het PowerShell-script: Dit script voert de daadwerkelijke implementatie van de Azure-infrastructuur uit met behulp van een Bicep-sjablonen.

Het hoofd-YML-script

Dit script vormt de basis van de CI/CD-pipeline in Azure DevOps. Het specificeert de te gebruiken variabelen, stadia (stages) en taken (jobs). Hier is een overzicht:

name: DP infrastructure
pool:
  vmImage: windows-latest

variables:
- template: /variables/general.yml
- template: /variables/serviceconnections.yml

trigger:
- none
pr: none

stages:
- stage: deploy_development
  variables:
  - template: /variables/environment/development.yml
  displayName: Deploy development environment
  jobs:
      - template: /pipelines/infrastructure/templates/deploy-fabric-environment.yml
        parameters:
          serviceconnection: $(Serviceconnection.DevTest)
          environment: development

- stage: deploy_test
  variables:
  - template: /variables/environment/test.yml
  displayName: Deploy test environment
  jobs:
      - template: /pipelines/infrastructure/templates/deploy-fabric-environment.yml
        parameters:
          serviceconnection: $(Serviceconnection.DevTest)
          environment: test

In dit script worden de stadia deploy_development en deploy_test gedefinieerd, die elk een taak bevatten. Dit YML-bestand verwijst naar meerdere sjablonen die de details van de implementatie bevatten in de vorm van variabelen.

test.yml:

variables:
- name: Environment.Prefix
  value: t
- name: Environment.Serviceconnection
  value: ${{ variables.Serviceconnection.DevTest }}

general.yml:

variables:
- name: Resource.Location
  value: westeurope
- name: ApplicationName
  value: YY
- name: ResourceSuffix
  value: $(RegionAbbreviation)-$(RegionSuffix)
- name: CompanyName
  value: XX
- name: RegionAbbreviation
  value: weu
- name: RegionSuffix
  value: '001'
- name: Fabric.SkuName
  value: F2

serviceconnections.yml:

variables:
- name: 'Serviceconnection.DevTest'
  value: 'xx-yy-dta'
- name: 'Serviceconnection.Production'
  value: 'xx-yy-prd'

Het implementatie-YML-script ( deploy-fabric-environment.yml )

Dit script wordt aangeroepen door het hoofd-YML-script. Het geeft parameters door aan het PowerShell-script dat de Fabric-infrastructuur implementeert:

parameters:
- name: serviceconnection
- name: environment

jobs:
  - deployment: 'deploy_fabric_infrastructure'
    environment:
      name: ${{ parameters.environment }}
    displayName: 'Deploy Fabric Infrastructure'
    strategy:
      runOnce:
        deploy:
          steps:
          - checkout: self
          - task: AzurePowerShell@5
            displayName: 'Deploy infrastructure'
            inputs:
              azureSubscription: ${{ parameters.serviceconnection }}
              ScriptType: 'FilePath'
              azurePowerShellVersion: 'LatestVersion'
              ScriptPath: $(System.DefaultWorkingDirectory)\pipelines\infrastructure\scripts\rollout-fabric-infrastructure.ps1
              ScriptArguments: |
                -resourceLocation $(Resource.Location) `
                -applicationName $(ApplicationName) `
                -resourceSuffix $(ResourceSuffix) `
                -environmentPrefix $(Environment.Prefix) `
                -companyName $(CompanyName)

Het PowerShell-script

Het PowerShell-script voert de daadwerkelijke implementatie uit. Het script installeert de Microsoft Graph-module, haalt de huidige Azure-context op en implementeert de Fabric-infrastructuur met behulp van een Bicep-sjabloon:

param(
    $resourceLocation,
    $applicationName,
    $resourceSuffix,
    $environmentPrefix,
    $companyName
)

Install-Module Microsoft.Graph

$graphToken = Get-AzAccessToken -ResourceTypeName MSGraph
Connect-MgGraph -AccessToken ($graphToken.Token | ConvertTo-SecureString -AsPlainText -Force)

$currentContext = Get-AzContext
$currentSubscriptionId = $currentContext.Subscription.Id

Write-Output "Current Subscription ID: $currentSubscriptionId"

$azSubscriptionDeploymentParameters = @{
    location           = $resourceLocation
    applicationName    = $applicationName
    resourceSuffix     = $resourceSuffix
    environmentPrefix  = $environmentPrefix
    companyName        = $companyName
}

$deployment = New-AzSubscriptionDeployment `
    -Location $resourceLocation `
    -TemplateFile "$env:SYSTEM_DEFAULTWORKINGDIRECTORY\pipelines\infrastructure\bicep\fabric_infrastructure.bicep" `
    -TemplateParameterObject $azSubscriptionDeploymentParameters

$resourceGroupName = $deployment.Outputs._resourceGroupName.value
$fabResourceName = $deployment.Outputs._fabResourceName.value

Write-Output "General Resource Group Name: $resourceGroupName"
Write-Output "Fabric Resource Name: $fabResourceName"

De parameters geven wij mee via “$azSubscriptionDeploymentParameters”. Daarnaast specificeren we ook de locatie (regio) en het pad naar de betreffende Bicep-sjabloon. 
Het Bicep-sjabloon definieert de Fabric-infrastructuur. Een Fabric-infrastructuur kan uit meerdere onderdelen bestaan. Onderstaand script laat (inactief gezet) zien dat het ook een key vault en een storage account kan uitrollen. 
param location string = 'westeurope'
param applicationName string
param resourceSuffix string 
param environmentPrefix string
param companyName string

var resourceTypeReplacement = '{RT}'
var resourceNameTemplate = '${environmentPrefix}-${companyName}-${applicationName}-${resourceTypeReplacement}-${resourceSuffix}'
targetScope = 'subscription'

/*resource naming*/
var resourceGroupName   = replace(resourceNameTemplate, resourceTypeReplacement, 'rg')
var fabResourceName     = replace(replace(resourceNameTemplate, resourceTypeReplacement, 'fab'), '-','')
var dlsResourceName     = replace(replace(resourceNameTemplate, resourceTypeReplacement, 'dls'), '-','')
var kvResourceName      = replace(resourceNameTemplate, resourceTypeReplacement, 'kv')

resource generalResourceGroup 'Microsoft.Resources/resourceGroups@2020-10-01' = {
  name: resourceGroupName
  location: location
}

/*
module keyvaultModule 'modules/infrastructure/keyvault.bicep' = {
  name: 'keyvault'
  scope: generalResourceGroup
  params: {
    location: location
    name: replace(resourceNameTemplate, resourceTypeReplacement, 'kv')
  }
}

module storageModule 'modules/infrastructure/datalakestorage.bicep' = {
  name: 'storage'
  scope: generalResourceGroup
  params: {
    location: location
    dataLakeStorageName: replace(replace(resourceNameTemplate, resourceTypeReplacement, 'dls'), '-','')
  }
}
*/

module fabricModule 'modules/infrastructure/fabric.bicep' = {
  name: 'fabric'
  scope: generalResourceGroup
  params: {
    location: location
    name: fabResourceName
  }
}

output _fabResourceName string = fabResourceName
output _resourceGroupName string = resourceGroupName
output _dlsResourceName string = dlsResourceName
output _kvResourceName string = kvResourceName

Dit Bicep-sjabloon rolt ook de resourcegroup uit waarin wij de verschillende onderdelen van de Fabric-infrastructuur plaatsen. Voor naamgeving volgt het onze voorkeur voor benaming. 
Elk onderdeel heeft zijn eigen Bicep-sjabloon. Zo ook die van de Fabric-capaciteit:
param name string
param location string = resourceGroup().location
@allowed([
  'F2'
  'F4'
  'F8'
  'F16'
  'F32'
  'F64'
  'F128'
  'F256'
  'F512'
  'F1024'
  'F2048'
])
param skuName string = 'F2'
param skuTier string = 'Fabric'
@description('admin format: something@domain.nl')
param admin array = [
  'something@domain.nl'
]

resource fabricCapacities 'Microsoft.Fabric/capacities@2022-07-01-preview' = {
  name: toLower(name)
  location: location
  sku: {
    name: skuName
    tier: skuTier
  }
  properties: {
    administration: {
      members: admin
    }
  }
}

Dat is het complete overzicht van hoe deze scripts samenwerken om een Fabric-infrastructuur te implementeren. 
De volgende stap is om de capaciteit te koppelen aan een werkruimte en deze volgens een standaard in te richten zodat deze klaar is voor gebruik. Denk hierbij aan standaard naamgeving, lakehouses en inrichting van autorisaties.

Blijf ons volgen voor een volgende blog waarin we delen hoe je dat zou kunnen doen.