Øvelse – klargør Azure-ressourcer

  • 10 minutter

I denne øvelse skal du konfigurere en automatiseringsarbejdsproces for at klargøre dine Terraform-ressourcer.

Få adgang til eksempelprogrammet

I denne øvelse skal du oprette et GitHub-lager ud fra en skabelon, der indeholder al koden til klargøring af Terraform.

  1. På GitHub skal du gå til hovedsiden i lageret:

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

  2. Over fillisten skal du vælge Brug denne skabelonog derefter vælge Opret et nyt lager.

    Skærmbillede af knappen

  3. I feltet Lagernavn skal du angive et entydigt navn til dit lager. Sørg for at følge navngivningskonventionen for GitHub-lagre.

  4. Sørg for, at indstillingen Private er valgt, og vælg derefter Opret lager.

    Skærmbillede af knappen

Workflow

I projektmappen for det lager, du har oprettet, kan du se en mappe med navnet terraform og i den en fil, der kaldes main.tf.

Lad os se på et par afsnit, som du kan bruge til at definere konfigurationen af dit modul:

  • Provider: En Terraform-konfigurationsfil starter med providerens specifikation. Når du bruger Azure, angiver du Azure-udbyderen (azurerm) i udbyderblokken.
  • Terraform: Den Terraform-version, du arbejder med.
  • Data: Henter data fra eksisterende tjenester.
  • Locals: Genererer nye variabler ved hjælp af funktioner og udtryk.
  • Ressource: Beskriver ressourcer og afhængigheder.
  • Modul: Abstraktion af genbrug og kompleksitet.

Hvis du vil klargøre vores program og database, skal vi kun inkludere afsnittene Provider og Resource.

Åbn derefter main.tf-filen, og gennemse dispositionen og kommentarerne:

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
  }
}

Konfigurer din Arbejdsproces for GitHub-handlinger med Terraform

Lad os give din GitHub-arbejdsprocesadgang til din Azure-konto.

Opret en tjenesteprincipal på kommandolinjegrænsefladen i Azure ved at køre følgende kommando:

Vigtig

Erstat <yourServicePrincipalName> med det tjenesteprincipalnavn, du vil bruge.

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

Den foregående kommando returnerer følgende JSON. Kopiér den til brug i næste trin:

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

GitHub-hemmeligheder

Dit GitHub-lager har en funktion med navnet Hemmeligheder, hvor du kan gemme følsomme oplysninger, der bruges af Terraform til godkendelse i Azure.

Når du har oprettet de påkrævede id'er og hemmeligheden i det foregående trin, er det næste trin i dette undermodul at føje dem til butikken Hemmeligheder i dit GitHub-projekt.

I denne øvelse skal du gemme følgende hemmeligheder:

  • AZURE_CLIENT_ID
  • AZURE_CLIENT_SECRET
  • AZURE_SUBSCRIPTION_ID
  • AZURE_TENANT_ID

Hvis du vil gemme hemmelighederne, skal du gå til dit kopierede GitHub-lager, vælge Indstillingerog derefter vælge Hemmeligheder og variablerog derefter vælge Handlinger i venstre rude.

Opret fire hemmeligheder ved hjælp af de værdier, der returneres fra oprettelsen af tjenesteprincipalen.

Sørg for at gemme hemmelighederne uden anførselstegnene (" "), som vist på følgende skærmbillede:

Skærmbillede, der viser gemte hemmeligheder i ruden Hemmeligheder under GitHub-indstillinger.

Arbejdsprocesfil

I projektmappen findes en mappe, der kaldes .github/arbejdsprocesser, og i den en fil, der kaldes main.yml.

Filen main.yml er en GitHub-arbejdsproces. Den bruger den hemmelighed, du har konfigureret til at installere dit program på dit Azure-abonnement.

I den main.yml arbejdsprocesfil finder du følgende indhold:

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

Denne arbejdsproces udfører følgende handlinger:

  • Den kontrollerer, om konfigurationen er formateret korrekt.
  • Den genererer en plan for hver pullanmodning.
  • Den udløser konfigurationen, når du opdaterer filer i mappen terraform.

Seddel

Du kan også udløse arbejdsprocessen For GitHub-handlinger ved at gå til Handlinger, vælge arbejdsprocessen Terraform og vælge Kør eksisterende job igen.

Udløs arbejdsprocessen

Derefter skal du i dit lager udløse din GitHub-handling ved at:

  1. I den indbyggede GitHub-teksteditor eller i en editor efter eget valg skal du redigere terraform/variables.tf som følger:

    en. Skift "CHANGE_ME_RESOURCE_GROUP" til navnet på den ønskede ressourcegruppe.
    b. Skift "CHANGE_ME_APP_NAME" til det ønskede programnavn. Sørg for, at dit programnavn er entydigt.

    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. Bekræft dine ændringer.

Bekræft GitHub-handlingsbuildet

  1. Vælg Handlingeri dit lager, og vælg derefter arbejdsprocessen TERRAFORM i venstre rude.

  2. På listen over trin skal du kontrollere, at Terraform Init, Terraform Planog Terraform Validate er blevet udløst.

    Skærmbillede, der viser resultaterne af kørslen af arbejdsprocessen Terraform.

  3. Udvid Terraform Anvendpå listen over trin, og bekræft, at:

  • Terraform har oprettet ressourcerne og viser URL-adressen til Azure-forekomsten.

  • Din Azure-appforekomst er offentligt tilgængelig.

    Skærmbillede, der viser, at Azure-appforekomsten er offentligt tilgængelig.

Næste trin

I den næste øvelse skal du bruge GitHub-handlinger til at installere et eksempel på et spring boot-program.

Konfigurer dit programnavn og din Azure-ressourcegruppe

Rediger navnene på dine Azure-ressourcer i dit GitHub-lager ved at udføre følgende handling:

  1. I den indbyggede GitHub-teksteditor eller i en editor efter eget valg skal du redigere terraform/variables.tf som følger:

    en. Skift "<CHANGE_ME_RESOURCE_GROUP>" til navnet på den ønskede ressourcegruppe.
    b. Skift "<CHANGE_ME_APP_NAME>" til det ønskede programnavn. Sørg for, at dit programnavn er entydigt.

    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. Bekræft dine ændringer

Opret en Azure Pipeline for at klargøre dine Terraform-ressourcer

I vores Azure DevOps-projekt opretter vi to separate pipelines til klargøring og build-and-deploy. Klargøringspipelinen opretter de Azure-ressourcer, der frigives via build-and-deploy-pipelinen på et senere tidspunkt.

Lad os oprette den første klargøringspipeline:

  1. Vælg din organisation, og vælg derefter Nyt projekt.

  2. Angiv følgende parametre.

    Parameter Beskrivelse
    Projektnavn Kræves
    Beskrivelse Valgfri
    Synlighed Vælg privat
    Avanceret
    Versionsstyring Vælg GIT-
    Arbejdsproces for arbejdselement Vælg Basic-

  3. Vælg Opret projekt for at oprette projektet og åbne en velkomstside.

Skærmbillede, der viser den nye Azure Project-formular.

Konfigurer din Azure Pipeline Service-forbindelse

Lad os give din Azure Pipeline adgang til din Azure-konto.

  1. I Azure DevOps skal du åbne siden Service-forbindelser fra siden med projektindstillinger

  2. Vælg Opret tjenesteforbindelse, og vælg Azure Resource Manager, og vælg derefter Næste.

  3. Vælg tjenesteprincipal (automatisk), og vælg derefter Næste.

  4. Angiv følgende parametre.

    Parameter Beskrivelse
    Områdeniveau Vælg Azure-abonnement
    Abonnement Vælg dit eksisterende Azure-abonnement
    Ressourcegruppe Lad argumentet være tomt for at give brugerne adgang til alle de ressourcer, der er defineret i abonnementet
    Forbindelsesnavn Kræves. Det navn, du skal bruge til at referere til denne tjenesteforbindelse i opgaveegenskaber. Dette navn er ikke navnet på dit Azure-abonnement.

  5. Vælg Gem for at oprette forbindelsen.

Opret klargøringspipeline

Vigtig

Dette moduls forudsætninger krævede, at du installere udvidelsen Terraform Azure Pipelines. Hvis du ikke har installeret den, kører din pipeline ikke.

Når du har konfigureret dit projekt og forbindelse til Azure, skal du oprette en Azure Pipeline for at klargøre dine terraformressourcer.

I Azure DevOps skal du gå til dit projekt, vælge Pipelines i menuen til venstre og derefter vælge Opret pipeline.

  1. Under fanen "Opret forbindelse" skal du vælge "GitHub" (YAML-fil).
  2. Hvis du bliver bedt om at godkende GitHub-adgang, skal du angive dine GitHub-legitimationsoplysninger og godkende adgangen til Azure Pipelines med de ønskede rettigheder.
  3. På fanen "Vælg" skal du vælge det GitHub-lager, der indeholder skabelonen.
  4. Vælg Konfigurer pipeline under fanen Inventory.
  5. På fanen "Configure" skal du vælge at bruge en "Existing Azure Pipelines YAML-fil".
  6. Vælg "/azuredevops/provision.yml" i stien
  7. Vælg Fortsæt for at gå til fanen Gennemse og gennemse din pipeline.

Skærmbillede, der viser den nye Azure Pipeline-formular.

Lad os undersøge den Yaml-fil, vi bruger til at oprette vores pipeline, på skærmen "Gennemse din pipeline YAML".

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)

Lad os se på nogle af de felter, vi bruger i konfigurationen:

  • serviceConnection: Din Azure PipeLine Service-forbindelse tidligere
  • kommando: Kommandoen Terraform-arbejdsproces: init eller anvende
  • backendAzure: Obligatoriske felter, der kræves i et teammiljø for at gemme delt tilstand.\

Før du gemmer og kører pipelinen, skal vi tilføje den variabel, der binder til din tjenesteforbindelse:

  1. Vælg Variabler (øverst til højre), og tilføj en variabel med navnet "serviceConnection" med værdien som navnet på tjenesteforbindelsen.
  2. Vælg OK (nederste højre hjørne) for at gemme variablen.

Skærmbillede, der viser den nye variabel Tjenesteprincipal.

Til sidst skal du vælge "køre" (øverste højre hjørne) for at gemme og køre pipelinen

Se pipelinen køre

Under Job skal du spore buildprocessen gennem hvert af trinnene.

Når pipelinen kører, kan du se, mens din første Terraform-starte fase, og derefter din anden anvende fase, gå fra blå (løbende) til grøn (fuldført). Du kan vælge faserne for at se din pipeline i aktion.

Skærmbillede, der viser den nye Azure Pipeline-kørsel.

Drikkepenge

Kontrollér din mail. Du har måske allerede modtaget en buildmeddelelse med resultaterne af din kørsel. Du kan bruge disse meddelelser til at vide, om hvert build består eller mislykkes.

Næste trin

I den næste øvelse skal du bruge Azure Pipelines til at bygge og udrulle dit eksempel på spring boot-program.