Oefening: Azure-resources inrichten

Voltooid

In deze oefening configureert u een automatiseringswerkstroom om uw Terraform-resources in te richten.

Toegang tot de voorbeeldtoepassing

In deze oefening maakt u een GitHub-opslagplaats op basis van een sjabloon die alle code voor Terraform-inrichting bevat.

1. Ga op GitHub naar de hoofdpagina van de opslagplaats:

   https://github.com/MicrosoftDocs/mslearn-java-petclinic-simplified
   

2. Selecteer boven de lijst met bestanden de optie Deze sjabloon gebruiken en selecteer vervolgens Een nieuwe opslagplaats maken.

   

3. Voer in het vak Opslagplaatsnaam een unieke naam in voor uw opslagplaats. Zorg ervoor dat u de naamconventie voor GitHub-opslagplaatsen volgt.

4. Zorg ervoor dat de optie Privé is geselecteerd en selecteer vervolgens Opslagplaats maken.

   

Workflow

In de projectmap voor de opslagplaats die u hebt gemaakt, ziet u een map met de naam terraform en daarin een bestand met de naam main.tf.

Laten we eens kijken naar enkele secties die u kunt gebruiken om de configuratie van uw module te definiëren:

• Provider: Een Terraform-configuratiebestand begint met de specificatie van de provider. Wanneer u Azure gebruikt, geeft u de Azure-provider (azurerm) op in het providerblok.
• Terraform: De Terraform-versie waarmee u werkt.
• Gegevens: haalt gegevens op uit bestaande services.
• Locals: Genereert nieuwe variabelen met behulp van functies en expressies.
• Resource: Beschrijft resources en afhankelijkheden.
• Module: Herbruikbaarheid en complexiteit abstractie.

Als u onze toepassing en database wilt inrichten, hoeven we alleen de secties Provider en Resource op te nemen.

Open vervolgens het bestand main.tf en bekijk het overzicht en de opmerkingen:

provider "azurerm" {
  version = "=2.20.0"
  features {}
}

# Creates a resource group
resource "azurerm_resource_group" "main" {
  name     = var.resource_group
  location = var.location

  tags = {
    "Terraform" = "true"
  }
}

resource "random_password" "password" {
  length = 32
  special = true
  override_special = "_%@"
}

# Creates a MySQL server
resource "azurerm_mysql_server" "main" {
  name                              = "${azurerm_resource_group.main.name}-mysql-server"
  location                          = azurerm_resource_group.main.location
  resource_group_name               = azurerm_resource_group.main.name

  administrator_login               = "petclinic"
  administrator_login_password      = random_password.password.result

  sku_name   = "B_Gen5_1"
  storage_mb = 5120
  version    = "5.7"
  auto_grow_enabled                 = true
  backup_retention_days             = 7
  geo_redundant_backup_enabled      = false
  infrastructure_encryption_enabled = false
  public_network_access_enabled     = true
  ssl_enforcement_enabled           = true
  ssl_minimal_tls_version_enforced  = "TLS1_2"
}

# The database that your application will use
resource "azurerm_mysql_database" "main" {
  name                = "${azurerm_resource_group.main.name}_mysql_db"
  resource_group_name = azurerm_resource_group.main.name
  server_name         = azurerm_mysql_server.main.name
  charset             = "utf8"
  collation           = "utf8_unicode_ci"
}

# Enables the 'Allow access to Azure services' check box
resource "azurerm_mysql_firewall_rule" "main" {
  name                = "${azurerm_resource_group.main.name}-mysql-firewall"
  resource_group_name = azurerm_resource_group.main.name
  server_name         = azurerm_mysql_server.main.name
  start_ip_address    = "0.0.0.0"
  end_ip_address      = "0.0.0.0"
}

# Creates the plan that the service uses
resource "azurerm_app_service_plan" "main" {
  name                = "${var.application_name}-plan"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  kind                = "Linux"
  reserved            = true

  sku {
    tier = "PremiumV2"
    size = "P1v2"
  }
}

# Creates the service definition
resource "azurerm_app_service" "main" {
  name                = var.application_name
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  app_service_plan_id = azurerm_app_service_plan.main.id
  https_only          = true

  site_config {
    always_on        = true
    linux_fx_version = "JAVA|8-jre8"
  }

  # Contains application-specific environment variables
  app_settings = {
    "WEBSITES_ENABLE_APP_SERVICE_STORAGE" = "false"

    "SPRING_PROFILES_ACTIVE"     = "mysql"
    "SPRING_DATASOURCE_URL"      = "jdbc:mysql://${azurerm_mysql_server.main.fqdn}:3306/${azurerm_mysql_database.main.name}?useUnicode=true&characterEncoding=utf8&useSSL=true&useLegacyDatetimeCode=false&serverTimezone=UTC"
    "SPRING_DATASOURCE_USERNAME" = "${azurerm_mysql_server.main.administrator_login}@${azurerm_mysql_server.main.name}"
    "SPRING_DATASOURCE_PASSWORD" = azurerm_mysql_server.main.administrator_login_password
  }
}

Uw GitHub Actions-werkstroom instellen met Terraform

Laten we uw GitHub-werkstroomtoegang bieden tot uw Azure-account.

Maak in de Azure CLI een service-principal door de volgende opdracht uit te voeren:

Belangrijk

Vervang <yourServicePrincipalName> door de naam van de service-principal die u wilt gebruiken.

az ad sp create-for-rbac --name "<yourServicePrincipalName>" --role contributor --scopes /subscriptions/<subscriptionId> --sdk-auth

Met de voorgaande opdracht wordt de volgende JSON geretourneerd. Kopieer deze voor gebruik in de volgende stap:

{
  "clientId": "XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXX",
  "clientSecret": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
  "subscriptionId": "XXXXXXXXX-XXXXX-XXXX-XXXX-XXXXXXXXXXXXX",
  "tenantId": "XXXXXXXX-XXXXX-XXXX-XXXX-XXXXXXXXXXX",
  ...
}

GitHub-geheimen

Uw GitHub-opslagplaats heeft een functie met de naam Geheimen, waar u gevoelige informatie kunt opslaan die door Terraform wordt gebruikt om te verifiëren bij Azure.

Nadat u de vereiste id's en het geheim in de vorige stap hebt gemaakt, is de volgende stap in deze les het toevoegen aan het geheimenarchief in uw GitHub-project.

Voor deze oefening moet u de volgende geheimen opslaan:

• AZURE_CLIENT_ID
• AZURE_CLIENT_SECRET
• AZURE_SUBSCRIPTION_ID
• AZURE_TENANT_ID

Als u de geheimen wilt opslaan, gaat u naar uw geforkte GitHub-opslagplaats, selecteert u Instellingen en selecteert u Geheimen en variabelen en selecteert u vervolgens Acties in het linkerdeelvenster.

Maak vier geheimen met behulp van de waarden die worden geretourneerd bij het maken van de service-principal.

Zorg ervoor dat u de geheimen zonder aanhalingstekens (" ") opslaat, zoals wordt weergegeven in de volgende schermopname:

Werkstroombestand

In uw projectmap bevindt zich een map met de naam .github/workflows en daarin een bestand met de naam main.yml.

Het main.yml-bestand is een GitHub-werkstroom. Het maakt gebruik van het geheim dat u hebt geconfigureerd om uw toepassing te implementeren in uw Azure-abonnement.

In het main.yml werkstroombestand vindt u de volgende inhoud:

name: TERRAFORM

on:
  push:
    branches: [ main ]
    paths:
    - 'terraform/**'
  pull_request:
    branches: [ main ]
    paths:
    - 'terraform/**'

  workflow_dispatch:
jobs:
  terraform:
    runs-on: ubuntu-latest

    env:
      ARM_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
      ARM_CLIENT_SECRET: ${{secrets.AZURE_CLIENT_SECRET}}
      ARM_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
      ARM_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}

    defaults:
      run:
        working-directory: ./terraform
    steps:
      - uses: actions/checkout@v2

      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v1

      - name: Terraform Init
        run: terraform init

      - name: Terraform Plan
        run: terraform plan

      - name: Terraform Apply
        run: terraform apply -auto-approve

Deze werkstroom voert de volgende acties uit:

• Er wordt gecontroleerd of de configuratie juist is opgemaakt.
• Er wordt een plan gegenereerd voor elke pull-aanvraag.
• Hiermee wordt de configuratie geactiveerd wanneer u bestanden in de terraform-map bijwerkt .

Notitie

U kunt ook de GitHub Actions-werkstroom activeren door naar Actions te gaan, de Terraform-werkstroom te selecteren en bestaande taken opnieuw uit te voeren.

De werkstroom activeren

Activeer vervolgens in uw opslagplaats de GitHub-actie door:

1. Bewerk terraform/variables.tf als volgt in de ingebouwde GitHub-teksteditor of in een editor naar keuze:

   a. Ga naar "CHANGE_ME_RESOURCE_GROUP" de naam van de beoogde resourcegroep.
   b. Ga naar "CHANGE_ME_APP_NAME" de naam van de beoogde toepassing. Zorg ervoor dat de naam van uw toepassing uniek is.

   variable "resource_group" {
     description = "The resource group"
     default = "CHANGE_ME_RESOURCE_GROUP"
   }
   
   variable "application_name" {
     description = "The Spring Boot application name"
     default     = "CHANGE_ME_APP_NAME"
   }
   
   variable "location" {
     description = "The Azure location where all resources in this example should be created"
     default     = "westeurope"
   }
   

2. Voer uw wijzigingen door.

De GitHub Actions-build controleren

1. Selecteer acties in uw opslagplaats en selecteer vervolgens de TERRAFORM-werkstroom in het linkerdeelvenster.

2. Controleer in de lijst met stappen of Terraform Init, Terraform Plan en Terraform Validate zijn geactiveerd.

   

3. Vouw Terraform Apply uit in de lijst met stappen en controleer of:

• Terraform heeft de resources gemaakt en de URL van het Azure-exemplaar weergegeven.

• Uw Azure-app-exemplaar is openbaar beschikbaar.

  

Volgende stappen

In de volgende oefening gebruikt u GitHub Actions om een Spring Boot-voorbeeldtoepassing te implementeren.

Uw toepassingsnaam en Azure-resourcegroep instellen

Bewerk uw Azure-resourcenamen in uw GitHub-opslagplaats door de volgende actie uit te voeren:

1. Bewerk terraform/variables.tf als volgt in de ingebouwde GitHub-teksteditor of in een editor naar keuze:

   a. Ga naar "<CHANGE_ME_RESOURCE_GROUP>" de naam van de beoogde resourcegroep.
   b. Ga naar "<CHANGE_ME_APP_NAME>" de naam van de beoogde toepassing. Zorg ervoor dat de naam van uw toepassing uniek is.

   variable "resource_group" {
     description = "The resource group"
     default = "<CHANGE_ME_RESOURCE_GROUP>"
   }
   
   variable "application_name" {
     description = "The Spring Boot application name"
     default     = "CHANGE_ME_APP_NAME"
   }
   
   variable "location" {
     description = "The Azure location where all resources in this example should be created"
     default     = "westeurope"
   }
   

2. Uw wijzigingen doorvoeren

Een Azure-pijplijn maken om uw Terraform-resources in te richten

In ons Azure DevOps-project maken we twee afzonderlijke pijplijnen voor het inrichten en bouwen en implementeren. Met de inrichtingspijplijn worden de Azure-resources gemaakt die op een later moment worden vrijgegeven via de build-and-deploy-pijplijn.

Laten we de eerste inrichtingspijplijn maken:

1. Kies uw organisatie en selecteer vervolgens Nieuw project.

2. Geef de volgende parameters op.

   Parameter	Description
   Projectnaam	Vereist
   Description	Optioneel
   Visibility	Privé kiezen
   Geavanceerd
   Versiebeheer	Git kiezen
   Werkitemproces	Basis kiezen

3. Selecteer Project maken om het project te maken en een welkomstpagina te openen.

Uw Azure Pipeline Service-verbinding instellen

Laten we uw Azure Pipeline toegang geven tot uw Azure-account.

1. Open in Azure DevOps de pagina Serviceverbindingen vanaf de pagina met projectinstellingen

2. Kies Serviceverbinding maken en selecteer Azure Resource Manager en selecteer vervolgens Volgende.

3. Selecteer Service-principal (automatisch) en selecteer vervolgens Volgende.

4. Geef de volgende parameters op.

   Parameter	Description
   Bereikniveau	Azure-abonnement selecteren
   Abonnement	Uw bestaande Azure-abonnement selecteren
   Resourcegroep	Laat leeg om gebruikers toegang te geven tot alle resources die in het abonnement zijn gedefinieerd
   Naam verbinding	Vereist. De naam die u gebruikt om te verwijzen naar deze serviceverbinding in taakeigenschappen. Deze naam is niet de naam van uw Azure-abonnement.

5. Selecteer Opslaan om de verbinding te maken.

De inrichtingspijplijn maken

Belangrijk

Voor deze module is vereist dat u de Terraform Azure Pipelines-extensie installeert. Als u deze nog niet hebt geïnstalleerd, wordt uw pijplijn niet uitgevoerd.

Nadat u uw project en verbinding met Azure hebt ingesteld, moet u een Azure-pijplijn maken om uw terraform-resources in te richten.

Ga in Azure DevOps naar uw project, selecteer Pijplijnen in het menu aan de linkerkant en selecteer Vervolgens Pijplijn maken.

1. Selecteer op het tabblad Verbinding maken de optie 'GitHub' (YAML-bestand).
2. Als u wordt gevraagd om GitHub-toegang te autoriseren, voert u uw GitHub-referenties in en keurt u de toegang voor Azure Pipelines goed met de aangevraagde bevoegdheden.
3. Selecteer op het tabblad Selecteren de GitHub-opslagplaats met uw sjabloon.
4. Selecteer Pijplijn configureren op het tabblad Inventaris .
5. Selecteer op het tabblad Configureren een YAML-bestand voor bestaande Azure Pipelines.
6. Selecteer '/azuredevops/provision.yml' in het pad
7. Selecteer Doorgaan om naar het tabblad Controleren te gaan en uw pijplijn te controleren.

In het scherm 'Uw pijplijn YAML controleren' gaan we het Yaml-bestand inspecteren dat we gaan gebruiken om onze pijplijn te maken.

name: Provision Resources

trigger: none

pool:
  vmImage: 'ubuntu-latest'

steps:

# Initialize the Terraform environment and bind to your Service Connection
- task: TerraformTaskV1@0
  inputs:
    provider: 'azurerm'
    command: 'init'
    workingDirectory: $(Build.Repository.LocalPath)/terraform
    backendServiceArm: $(serviceConnection)
    backendAzureRmResourceGroupName: $(serviceConnection)
    backendAzureRmStorageAccountName: $(serviceConnection)
    backendAzureRmContainerName: 'tfstate'
    backendAzureRmKey: 'tf/terraform.tfstate'

# Apply the Terraform config and deploy to Azure
- task: TerraformTaskV1@0
  inputs:
    provider: 'azurerm'
    command: 'apply'
    workingDirectory: $(Build.Repository.LocalPath)/terraform
    backendAzureRmContainerName: 'tfstate'
    backendAzureRmKey: 'tf/terraform.tfstate'
    environmentServiceNameAzureRM: $(serviceConnection)

Laten we eens kijken naar enkele van de velden die we gebruiken in de configuratie:

• serviceConnection: uw Azure PipeLine-serviceverbinding die u eerder hebt ingesteld
• opdracht: uw Terraform-werkstroomopdracht: init of toepassen
• backendAzure: vereiste velden die nodig zijn in een teamomgeving om de gedeelde status op te slaan.\

Voordat u de pijplijn opslaat en uitvoert, moeten we de variabele toevoegen die wordt gekoppeld aan uw serviceverbinding:

1. Selecteer Variabelen (rechtsboven) en voeg een variabele met de naam serviceConnection toe met de waarde als de naam van uw serviceverbinding.
2. Selecteer OK (rechterbenedenhoek) om de variabele op te slaan.

Selecteer ten slotte Uitvoeren (rechterbovenhoek) om de pijplijn op te slaan en uit te voeren

De pijplijnuitvoering bekijken

Onder Taken kunt u het buildproces traceren via elk van de stappen.

Terwijl uw pijplijn wordt uitgevoerd, bekijkt u als uw eerste Terraform init-fase en vervolgens past u de tweede fase toe , van blauw (actief) naar groen (voltooid). U kunt de fasen selecteren om uw pijplijn in actie te bekijken.

Tip

Controleer uw e-mail. Mogelijk hebt u al een buildmelding ontvangen met de resultaten van uw uitvoering. U kunt deze meldingen gebruiken om te weten of elke build passeert of mislukt.

Volgende stappen

In de volgende oefening gebruikt u Azure Pipelines om uw Spring Boot-voorbeeldtoepassing te bouwen en te implementeren.