Øvelse – Klargjør Azure-ressurser

Fullført

I denne øvelsen skal du konfigurere en automatiseringsarbeidsflyt for å klargjøre Terraform-ressursene.

Få tilgang til eksempelprogrammet

I denne øvelsen skal du opprette et GitHub-repositorium fra en mal som inneholder all koden for Klargjøring av Terraform.

1. Gå til hovedsiden for repositoriet på GitHub:

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

2. Velg Bruk denne malenover fillisten, og velg deretter Opprett et nytt repositorium.

   

3. Skriv inn et unikt navn for repositoriet i boksen repositoriumnavn. Pass på at du følger navnekonvensjonen for GitHub-repositorier.

4. Kontroller at alternativet privat er valgt, og velg deretter Opprett repositorium.

   

Workflow

I prosjektkatalogen for repositoriet du har opprettet, ser du en katalog som heter terraform og, i den, en fil som heter main.tf.

La oss se på noen inndelinger som du kan bruke til å definere modulens konfigurasjon:

• provider: En Terraform-konfigurasjonsfil starter med spesifikasjonen til leverandøren. Når du bruker Azure, angir du Azure-leverandøren (azurerm) i leverandørblokken.
• Terraform: Terraform-versjonen du arbeider med.
• Data: Henter data fra eksisterende tjenester.
• Locals: Genererer nye variabler ved hjelp av funksjoner og uttrykk.
• Resource: Beskriver ressurser og avhengigheter.
• Module: Gjenbrukbarhet og kompleksitetsabstraksjon.

Hvis du vil klargjøre programmet og databasen, trenger vi bare å inkludere inndelingene leverandør og Ressurs.

Deretter åpner du main.tf-filen og ser gjennom disposisjonen og kommentarene:

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

Konfigurere Arbeidsflyt for GitHub-handlinger med Terraform

La oss gi GitHub-arbeidsflyttilgang til Azure-kontoen din.

Opprett en tjenestekontohaver i Azure CLI ved å kjøre følgende kommando:

Viktig

Erstatt <YourServicePrincipalName-> med tjenestekontohavernavnet du vil bruke.

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

Den foregående kommandoen returnerer følgende JSON. Kopier den for bruk i neste trinn:

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

GitHub-hemmeligheter

GitHub-repositoriet har en funksjon kalt Secrets, der du kan lagre sensitiv informasjon som brukes av Terraform til å godkjenne til Azure.

Når du har opprettet de nødvendige ID-ene og hemmeligheten i det foregående trinnet, er neste trinn i denne enheten å legge dem til i Secrets-butikken i GitHub-prosjektet.

For denne øvelsen må du lagre følgende hemmeligheter:

• AZURE_CLIENT_ID
• AZURE_CLIENT_SECRET
• AZURE_SUBSCRIPTION_ID
• AZURE_TENANT_ID

Hvis du vil lagre hemmelighetene, kan du gå til det forgrenede GitHub-repositoriet, velge Innstillinger, og deretter velge Hemmeligheter og variabler, og velg deretter Handlinger i venstre rute.

Opprett fire hemmeligheter ved hjelp av verdiene som returneres fra opprettelsen av tjenestekontohaveren.

Pass på å lagre hemmelighetene uten anførselstegn (" "), som vist i følgende skjermbilde:

Arbeidsflytfil

I prosjektkatalogen er en katalog kalt .github/workflows og en fil kalt main.yml.

Den main.yml filen er en GitHub-arbeidsflyt. Den bruker hemmeligheten du har konfigurert til å distribuere programmet til Azure-abonnementet.

I main.yml arbeidsflytfil finner du følgende innhold:

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 arbeidsflyten gjør følgende handlinger:

• Den kontrollerer om konfigurasjonen er riktig formatert.
• Det genererer en plan for hver pull-forespørsel.
• Det utløser konfigurasjonen når du oppdaterer filer i terraform-katalogen.

Notat

Du kan også utløse Arbeidsflyt for GitHub-handlinger ved å gå til Handlinger, velge Terraform-arbeidsflyten og velge Kjør eksisterende jobber på nytt.

Utløse arbeidsflyten

Deretter utløser du GitHub-handlingen i repositoriet ved å:

1. Rediger terraform/variables.tf som følger, i det innebygde redigeringsprogrammet for GitHub, eller i et redigeringsprogram du ønsker:

   en. Endre "CHANGE_ME_RESOURCE_GROUP" til det tiltenkte ressursgruppenavnet.
   b. Endre "CHANGE_ME_APP_NAME" til det tiltenkte programnavnet. Kontroller at programnavnet er unikt.

   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. Utfør endringene dine.

Bekreft byggeverktøyet for GitHub-handlinger

1. Velg Handlingeri repositoriet, og velg deretter TERRAFORM arbeidsflyt i den venstre ruten.

2. Kontroller at Terraform Init, Terraform Planog Terraform Validate er utløst i listen over trinn.

   

3. Utvid Terraform Bruki listen over trinn, og kontroller at:

• Terraform har opprettet ressursene og viser url-adressen for Azure-forekomsten.

• Azure-appforekomsten er offentlig tilgjengelig.

  

Neste trinn

I neste øvelse bruker du GitHub-handlinger til å distribuere et eksempel på spring boot-program.

Konfigurere programnavnet og Azure-ressursgruppen

Rediger Azure-ressursnavnene dine i GitHub-repositoriet ved å gjøre følgende:

1. Rediger terraform/variables.tf som følger, i det innebygde redigeringsprogrammet for GitHub, eller i et redigeringsprogram du ønsker:

   en. Endre "<CHANGE_ME_RESOURCE_GROUP>" til det tiltenkte ressursgruppenavnet.
   b. Endre "<CHANGE_ME_APP_NAME>" til det tiltenkte programnavnet. Kontroller at programnavnet er unikt.

   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. Utfør endringene dine

Opprett en Azure Pipeline for å klargjøre Terraform-ressursene dine

I Azure DevOps-prosjektet vårt oppretter vi to separate datasamlebånd for klargjøring og bygg og distribuering. Klargjøringssamlebåndet oppretter Azure-ressursene som vil bli utgitt via build-and-deploy-datasamlebåndet på et senere tidspunkt.

La oss opprette det første klargjøringsforløpet:

1. Velg organisasjonen, og velg deretter Nytt prosjekt.

2. Angi følgende parametere.

   Parameter	Beskrivelse
   Prosjektnavn	Påkrevd
   Beskrivelse	Valgfri
   Synlighet	Velg privat
   Avansert
   Versjonskontroll	Velg GIT-
   Arbeid elementprosess	Velg Grunnleggende

3. Velg Opprett prosjekt for å opprette prosjektet og åpne en velkomstside.

Konfigurere Azure Pipeline Service Connection

La oss gi Azure Pipeline tilgang til Azure-kontoen din.

1. Åpne siden Tjenestetilkoblinger fra siden for prosjektinnstillinger i Azure DevOps

2. Velg Opprett tjenestetilkobling, og velg Azure Resource Manager, og velg deretter Neste.

3. Velg tjenestekontohaver (automatisk), og velg deretter Neste.

4. Angi følgende parametere.

   Parameter	Beskrivelse
   Omfangsnivå	Velg Azure-abonnement
   Abonnement	Velg det eksisterende Azure-abonnementet
   Ressursgruppe	La være tom for å gi brukere tilgang til alle ressurser som er definert i abonnementet
   Tilkoblingsnavn	Påkrevd. Navnet du bruker til å referere til denne tjenestetilkoblingen i oppgaveegenskaper. Dette navnet er ikke navnet på Azure-abonnementet.

5. Velg Lagre for å opprette tilkoblingen.

Opprett klargjøringssamlebåndet

Viktig

Denne modulens forutsetninger krevde at du installerte utvidelsen Terraform Azure Pipelines. Hvis du ikke har installert det, kjører ikke datasamlebåndet.

Når du har konfigurert prosjektet og tilkoblingen til Azure, må du opprette en Azure Pipeline for å klargjøre ressurser for terraform.

Gå til Project i Azure DevOps, velg Pipelines i menyen til venstre, og velg deretter Opprett datasamlebånd.

1. VelgGitHub" (YAML-fil) på fanenKoble til".
2. Hvis du blir bedt om å godkjenne GitHub-tilgang, skriver du inn GitHub-legitimasjonen og godkjenner tilgangen for Azure Pipelines med de forespurte rettighetene.
3. Velg GitHub-repositoriet som inneholder malen, på fanenVelg".
4. Velg Konfigurer datasamlebånd på fanen inventory.
5. På fanenKonfigurervelger du å bruke en "eksisterende Azure Pipelines YAML-fil".
6. Velg «/azuredevops/provision.yml» i banen
7. Velg Fortsett for å gå Se gjennom-fanen og se gjennom datasamlebåndet.

La oss undersøke Yaml-filen vi skal bruke til å opprette datasamlebåndet, på skjermbildet «Se gjennom datasamlebåndets 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)

La oss se på noen av feltene vi bruker i konfigurasjonen:

• serviceConnection: Azure PipeLine Service Connection som er konfigurert tidligere
• kommando: Kommandoen Terraform-arbeidsflyt: init eller gjelder
• backendAzure: Obligatoriske felt som kreves i et gruppemiljø for å lagre delt tilstand.\

Før du lagrer og kjører datasamlebåndet, må vi legge til variabelen som binder seg til tjenestetilkoblingen:

1. Velg variabler (øverst til høyre), og legg til en variabel kalt "serviceConnection" med verdien som navnet på tjenestetilkoblingen.
2. Velg OK (nederst til høyre) for å lagre variabelen.

Til slutt velger du «kjøre» (øverst til høyre) for å lagre og kjøre datasamlebåndet

Se datasamlebåndet kjøre

Under Jobber sporer du byggeprosessen gjennom hvert av trinnene.

Når datasamlebåndet kjører, kan du se på den første Terraform-init fasen, og deretter bruke den andre fasen, gå fra blå (kjører) til grønn (fullført). Du kan velge fasene for å se datasamlebåndet i aksjon.

Tips

Kontroller e-postmeldingen. Du har kanskje allerede mottatt et build-varsel med resultatene av kjøringen. Du kan bruke disse varslene til å vite om hvert bygg passerer eller mislykkes.

Neste trinn

I den neste øvelsen skal du bruke Azure Pipelines til å bygge og distribuere programmet spring boot.