Föregående

Nästa

Övning – Etablera Azure-resurser

Slutförd

I den här övningen konfigurerar du ett automationsarbetsflöde för att etablera dina Terraform-resurser.

Få åtkomst till exempelprogrammet

I den här övningen skapar du en GitHub-lagringsplats från en mall som innehåller all kod för Terraform-etablering.

1. På GitHub går du till huvudsidan för lagringsplatsen:

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

2. Välj Använd den här mallen ovanför fillistan och välj sedan Skapa en ny lagringsplats.

   

3. I rutan Lagringsplatsnamn anger du ett unikt namn för lagringsplatsen. Följ namngivningskonventionen för GitHub-lagringsplatser.

4. Kontrollera att alternativet Privat är markerat och välj sedan Skapa lagringsplats.

   

Arbetsflöde

I projektkatalogen för den lagringsplats som du har skapat visas en katalog med namnet terraform och i den en fil med namnet main.tf.

Nu ska vi titta på några avsnitt som du kan använda för att definiera modulens konfiguration:

• Provider: En Terraform-konfigurationsfil börjar med providerns specifikation. När du använder Azure anger du Azure-providern (azurerm) i providerblocket.
• Terraform: Terraform-versionen som du arbetar med.
• Data: Hämtar data från befintliga tjänster.
• Lokalbefolkningen: Genererar nya variabler med hjälp av funktioner och uttryck.
• Resurs: Beskriver resurser och beroenden.
• Modul: Abstraktion av återanvändning och komplexitet.

För att etablera vårt program och vår databas behöver vi bara inkludera avsnitten Provider och Resurs .

Öppna sedan filen main.tf och granska dispositionen och kommentarerna:

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

Konfigurera ditt GitHub Actions-arbetsflöde med Terraform

Nu ska vi ge ditt GitHub-arbetsflöde åtkomst till ditt Azure-konto.

I Azure CLI skapar du ett huvudnamn för tjänsten genom att köra följande kommando:

Viktigt!

Ersätt <yourServicePrincipalName> med namnet på tjänstens huvudnamn som du vill använda.

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

Föregående kommando returnerar följande JSON. Kopiera den för användning i nästa steg:

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

GitHub-hemligheter

GitHub-lagringsplatsen har en funktion som kallas Hemligheter, där du kan lagra känslig information som används av Terraform för att autentisera till Azure.

När du har skapat de nödvändiga ID:na och hemligheten i föregående steg är nästa steg i den här lektionen att lägga till dem i hemlighetsarkivet i ditt GitHub-projekt.

I den här övningen måste du lagra följande hemligheter:

• AZURE_CLIENT_ID
• AZURE_CLIENT_SECRET
• AZURE_SUBSCRIPTION_ID
• AZURE_TENANT_ID

Om du vill lagra hemligheterna går du till din förgrenade GitHub-lagringsplats, väljer Inställningar och väljer sedan Hemligheter och variabler och sedan Åtgärder i den vänstra rutan.

Skapa fyra hemligheter med hjälp av de värden som returneras från skapandet av tjänstens huvudnamn.

Se till att lagra hemligheterna utan citattecken (" "), enligt följande skärmbild:

Arbetsflödesfil

I projektkatalogen finns en katalog med namnet .github/workflows och i den en fil med namnet main.yml.

Filen main.yml är ett GitHub-arbetsflöde. Den använder hemligheten som du har konfigurerat för att distribuera ditt program till din Azure-prenumeration.

I arbetsflödesfilen main.yml hittar du följande innehåll:

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

Det här arbetsflödet utför följande åtgärder:

• Den kontrollerar om konfigurationen är korrekt formaterad.
• Den genererar en plan för varje pull-begäran.
• Det utlöser konfigurationen när du uppdaterar filer i terraform-katalogen .

Kommentar

Du kan också utlösa GitHub Actions-arbetsflödet genom att gå till Åtgärder, välja Terraform-arbetsflödet och välja Kör befintliga jobb igen.

Utlösa arbetsflödet

I din lagringsplats utlöser du sedan din GitHub-åtgärd genom att:

1. I den inbyggda GitHub-textredigeraren, eller i valfri redigerare, redigerar du terraform/variables.tf på följande sätt:

   a. Ändra "CHANGE_ME_RESOURCE_GROUP" till det avsedda resursgruppsnamnet.
   b. Ändra "CHANGE_ME_APP_NAME" till ditt avsedda programnamn. Kontrollera att programnamnet är 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. Checka in ändringarna.

Verifiera GitHub Actions-versionen

1. Välj Åtgärder på lagringsplatsen och välj sedan TERRAFORM-arbetsflödet i den vänstra rutan.

2. I listan med steg kontrollerar du att Terraform Init, Terraform Plan och Terraform Validate har utlösts.

   

3. I listan med steg expanderar du Terraform Apply och kontrollerar att:

• Terraform har skapat resurserna och visar Azure-instansens URL.

• Din Azure-appinstans är offentligt tillgänglig.

  

Nästa steg

I nästa övning använder du GitHub Actions för att distribuera ett Spring Boot-exempelprogram.

Konfigurera programnamnet och Azure-resursgruppen

På din GitHub-lagringsplats redigerar du dina Azure-resursnamn genom att göra följande:

1. I den inbyggda GitHub-textredigeraren, eller i valfri redigerare, redigerar du terraform/variables.tf på följande sätt:

   a. Ändra "<CHANGE_ME_RESOURCE_GROUP>" till det avsedda resursgruppsnamnet.
   b. Ändra "<CHANGE_ME_APP_NAME>" till ditt avsedda programnamn. Kontrollera att programnamnet är 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. Genomföra ändringarna

Skapa en Azure Pipeline för att etablera dina Terraform-resurser

I vårt Azure DevOps-projekt skapar vi två separata pipelines för etablering och build-and-deploy. Etableringspipelinen skapar de Azure-resurser som släpps via pipelinen build-and-deploy vid ett senare tillfälle.

Nu ska vi skapa den första etableringspipelinen:

1. Välj din organisation och välj sedan Nytt projekt.

2. Ange följande parametrar.

   Parameter	Description
   Projektnamn	Obligatoriskt
   Beskrivning	Valfritt
   Synlighet	Välj Privat
   Avancerad
   Versionskontroll	Välj GIT
   Arbetsobjektsprocess	Välj Grundläggande

3. Välj Skapa projekt för att skapa projektet och öppna en välkomstsida.

Konfigurera Azure Pipeline Service-Anslut ion

Nu ska vi ge din Azure Pipeline åtkomst till ditt Azure-konto.

1. I Azure DevOps öppnar du sidan Tjänstanslutningar från sidan projektinställningar

2. Välj Skapa tjänstanslutning och välj Azure Resource Manager och välj sedan Nästa.

3. Välj Tjänstens huvudnamn (automatiskt)och välj sedan Nästa.

4. Ange följande parametrar.

   Parameter	Description
   Omfångsnivå	Välj Azure-prenumeration
   Prenumeration	Välj din befintliga Azure-prenumeration
   Resursgrupp	Lämna tomt för att tillåta användare att komma åt alla resurser som definierats i prenumerationen
   Anslutningsnamn	Obligatoriska. Namnet som du använder för att referera till den här tjänstanslutningen i aktivitetsegenskaper. Det här namnet är inte namnet på din Azure-prenumeration.

5. Välj Spara för att skapa anslutningen.

Skapa etableringspipelinen

Viktigt!

För den här modulen krävdes att du installerade Tillägget Terraform Azure Pipelines. Om du inte har installerat den körs inte pipelinen.

När du har konfigurerat projektet och anslutningen till Azure måste du skapa en Azure Pipeline för att etablera dina terraform-resurser.

I Azure DevOps går du till ditt projekt, väljer Pipelines på den vänstra menyn och väljer sedan Skapa pipeline.

1. På fliken "Anslut" väljer du "GitHub" (YAML-fil).
2. Om du uppmanas att auktorisera GitHub-åtkomst anger du dina GitHub-autentiseringsuppgifter och godkänner åtkomsten för Azure Pipelines med de begärda behörigheterna.
3. På fliken "Välj" väljer du den GitHub-lagringsplats som innehåller mallen.
4. Välj Konfigurera pipeline på fliken Inventering .
5. På fliken "Konfigurera" väljer du att använda en "Befintlig AZURE Pipelines YAML-fil".
6. I sökvägen väljer du "/azuredevops/provision.yml"
7. Välj Fortsätt för att gå till fliken Granska och granska din pipeline.

På skärmen "Granska din pipeline YAML" ska vi granska Yaml-filen som vi ska använda för att skapa vår pipeline.

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)

Nu ska vi titta på några av de fält som vi använder i konfigurationen:

• service Anslut ion: Din Azure PipeLine Service-Anslut jon som du konfigurerade tidigare
• kommando: Terraform-arbetsflödeskommandot: init eller apply
• backendAzure: Obligatoriska fält som behövs i en gruppmiljö för att lagra delat tillstånd.\

Innan du sparar och kör pipelinen måste vi lägga till variabeln som ska binda till tjänstanslutningen:

1. Välj Variabler (överst till höger) och lägg till en variabel med namnet "service Anslut ion" med värdet som namnet på din tjänst Anslut ion.
2. Välj OK (nedre högra hörnet) för att spara variabeln.

Välj slutligen "kör" (övre högra hörnet) för att spara och köra pipelinen

Titta på pipelinekörningen

Under Jobb spårar du byggprocessen genom vart och ett av stegen.

När pipelinen körs ser du som ditt första Terraform-initsteg och sedan din andra tillämpningsfas, går från blått (körs) till grönt (slutfört). Du kan välja stegen för att se hur din pipeline fungerar.

Dricks

Kontrollera din e-post. Du kanske redan har fått ett byggmeddelande med resultatet av körningen. Du kan använda dessa meddelanden för att veta om varje version godkänns eller misslyckas.

Nästa steg

I nästa övning använder du Azure Pipelines för att skapa och distribuera ditt Spring Boot-exempelprogram.

Fortsätt