Gyakorlat – Azure-erőforrások kiépítése

Befejeződött

Ebben a gyakorlatban egy automatizálási munkafolyamatot konfigurál a Terraform-erőforrások kiépítéséhez.

A mintaalkalmazás elérése

Ebben a gyakorlatban egy GitHub-adattárat fog létrehozni egy sablonból, amely tartalmazza a Terraform-kiépítés összes kódját.

1. A GitHubon nyissa meg az adattár főoldalát:

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

2. A fájllista fölött válassza a Sablon használata, majd az Új tárház létrehozása lehetőséget.

   

3. Az Adattár neve mezőben adjon meg egy egyedi nevet az adattárnak. Ügyeljen arra, hogy kövesse a GitHub-adattárak elnevezési konvencióit.

4. Győződjön meg arról, hogy a Privát beállítás be van jelölve, majd válassza az Adattár létrehozása lehetőséget.

   

Workflow

A létrehozott adattár projektkönyvtárában megjelenik egy terraform nevű könyvtár, benne pedig egy main.tf nevű fájl.

Tekintsünk meg néhány szakaszt, amelyeket a modul konfigurációjának meghatározásához használhat:

• Szolgáltató: A Terraform-konfigurációs fájl a szolgáltató specifikációjával kezdődik. Az Azure használatakor meg kell adnia az Azure-szolgáltatót (azurerm) a szolgáltatói blokkban.
• Terraform: Az a Terraform-verzió, amellyel dolgozik.
• Adatok: Lekéri az adatokat a meglévő szolgáltatásokból.
• Helyiek: Új változókat hoz létre függvények és kifejezések használatával.
• Erőforrás: Az erőforrásokat és függőségeket ismerteti.
• Modul: Újrafelhasználhatóság és összetett absztrakció.

Az alkalmazás és az adatbázis kiépítéséhez csak a Szolgáltató és az Erőforrás szakaszt kell belefoglalnunk.

Ezután nyissa meg a main.tf fájlt, és tekintse át a vázlatot és a megjegyzéseket:

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

A GitHub Actions-munkafolyamat beállítása a Terraform használatával

Biztosítsunk hozzáférést a GitHub-munkafolyamathoz az Azure-fiókjához.

Az Azure CLI-ben hozzon létre egy egyszerű szolgáltatást a következő parancs futtatásával:

Fontos

Cserélje le <aServicePrincipalName> nevet a használni kívánt szolgáltatásnévre.

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

Az előző parancs a következő JSON-t adja vissza. Másolja ki a következő lépésben való használatra:

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

GitHubos titkos kódok

A GitHub-adattár tartalmaz egy Titkos kulcsok nevű funkciót, ahol a Terraform által az Azure-ban történő hitelesítéshez használt bizalmas információkat tárolhatja.

Miután létrehozta a szükséges azonosítókat és a titkos kulcsokat az előző lépésben, ebben a leckében a következő lépés az, hogy hozzáadja őket a GitHub-projekt titkos kulcstárához.

Ehhez a gyakorlathoz a következő titkos kódokat kell tárolnia:

• AZURE_CLIENT_ID
• AZURE_CLIENT_SECRET
• AZURE_SUBSCRIPTION_ID
• AZURE_TENANT_ID

A titkos kulcsok tárolásához nyissa meg az elágaztatott GitHub-adattárat, válassza a Beállítások lehetőséget, majd válassza a Titkos kulcsok és változók lehetőséget, majd a bal oldali panelEn válassza a Műveletek lehetőséget .

Hozzon létre négy titkos kódot a szolgáltatásnév létrehozásakor visszaadott értékekkel.

Ügyeljen arra, hogy a titkos kulcsokat idézőjelek ("") nélkül tárolja, ahogyan az az alábbi képernyőképen látható:

Munkafolyamat-fájl

A projektkönyvtárban található egy .github/workflows nevű könyvtár, benne pedig egy main.yml nevű fájl.

A main.yml fájl egy GitHub-munkafolyamat. Az alkalmazás Azure-előfizetésben való üzembe helyezéséhez konfigurált titkos kulcsot használja.

A main.yml munkafolyamat-fájlban a következő tartalom található:

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

Ez a munkafolyamat a következő műveleteket hajtja végre:

• Ellenőrzi, hogy a konfiguráció megfelelően van-e formázva.
• Minden lekéréses kérelemhez létrehoz egy tervet.
• A terraform könyvtárban lévő fájlok frissítésekor aktiválja a konfigurációt .

Feljegyzés

A GitHub Actions munkafolyamatot a Műveletek, a Terraform-munkafolyamat kiválasztása és a meglévő feladatok újrafuttatása lehetőség kiválasztásával is aktiválhatja.

A munkafolyamat aktiválása

Ezután az adattárban aktiválja a GitHub-műveletet a következő módon:

1. A beépített GitHub-szövegszerkesztőben vagy egy tetszőleges szerkesztőben a terraform/variables.tf fájlt az alábbiak szerint szerkesztheti:

   a. Módosítsa "CHANGE_ME_RESOURCE_GROUP" a kívánt erőforráscsoport nevét.
   b. Módosítsa "CHANGE_ME_APP_NAME" a kívánt alkalmazásnevet. Győződjön meg arról, hogy az alkalmazás neve egyedi.

   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. Véglegesítse a módosításokat.

A GitHub Actions buildjének ellenőrzése

1. Az adattárban válassza a Műveletek lehetőséget, majd válassza a TERRAFORM munkafolyamatot a bal oldali panelen.

2. A lépések listájában ellenőrizze, hogy a Terraform Init, a Terraform Plan és a Terraform Validate aktiválva lett-e.

   

3. A lépések listájában bontsa ki a Terraform Apply elemet, és ellenőrizze, hogy:

• A Terraform létrehozta az erőforrásokat, és megjeleníti az Azure-példány URL-címét.

• Az Azure-alkalmazáspéldány nyilvánosan elérhető.

  

Következő lépések

A következő gyakorlatban a GitHub Actions használatával fog üzembe helyezni egy minta Spring Boot-alkalmazást.

Az alkalmazás nevének és az Azure-erőforráscsoportnak a beállítása

A GitHub-adattárban az alábbi művelet végrehajtásával szerkessze az Azure-erőforrásneveket:

1. A beépített GitHub-szövegszerkesztőben vagy egy tetszőleges szerkesztőben a terraform/variables.tf fájlt az alábbiak szerint szerkesztheti:

   a. Módosítsa "<CHANGE_ME_RESOURCE_GROUP>" a kívánt erőforráscsoport nevét.
   b. Módosítsa "<CHANGE_ME_APP_NAME>" a kívánt alkalmazásnevet. Győződjön meg arról, hogy az alkalmazás neve egyedi.

   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. A módosítások véglegesítése

Azure Pipeline létrehozása a Terraform-erőforrások kiépítéséhez

Az Azure DevOps-projektben két külön folyamatot hozunk létre a kiépítéshez és a buildeléshez és üzembe helyezéshez. A kiépítési folyamat létrehozza azokat az Azure-erőforrásokat, amelyeket a buildelési és üzembe helyezési folyamat egy későbbi időpontban fog felszabadítani.

Hozzuk létre az első kiépítési folyamatot:

1. Válassza ki a szervezetet, majd válassza az Új projekt lehetőséget.

2. Adja meg a következő paramétereket.

   Paraméter	Leírás
   Projekt neve	Kötelező
   Leírás	Lehetséges
   Láthatóság	Válassza a Privát lehetőséget
   Speciális
   Verziókövetés	Git kiválasztása
   Munkaelem folyamata	Válassza az Alapszintű lehetőséget

3. Válassza a Projekt létrehozása lehetőséget a projekt létrehozásához és egy üdvözlőlap megnyitásához.

Az Azure Pipeline Service-kapcsolat beállítása

Adjon hozzáférést az Azure Pipeline-nak az Azure-fiókjához.

1. Az Azure DevOpsban nyissa meg a Szolgáltatáskapcsolatok lapot a projektbeállítások lapon

2. Válassza a Szolgáltatáskapcsolat létrehozása lehetőséget, majd az Azure Resource Managert, majd a Tovább gombot.

3. Válassza a Szolgáltatásnév (automatikus) lehetőséget, majd a Tovább gombot.

4. Adja meg a következő paramétereket.

   Paraméter	Leírás
   Hatókör szintje	Azure-előfizetés kiválasztása
   Előfizetés	Meglévő Azure-előfizetés kiválasztása
   Erőforráscsoport	Hagyja üresen, hogy a felhasználók hozzáférhessenek az előfizetésben definiált összes erőforráshoz
   Kapcsolat neve	Szükséges. A szolgáltatáskapcsolatra a tevékenységtulajdonságokban hivatkozni kívánt név. Ez a név nem az Azure-előfizetés neve.

5. Válassza a Mentés lehetőséget a kapcsolat létrehozásához.

A kiépítési folyamat létrehozása

Fontos

A modul előfeltételei a Terraform Azure Pipelines bővítmény telepítéséhez szükségesek. Ha még nem telepítette, a folyamat nem fog futni.

A projekt és az Azure-hoz való csatlakozás beállítása után létre kell hoznia egy Azure Pipeline-t a terraform-erőforrások kiépítéséhez.

Az Azure DevOpsban nyissa meg a projektet, válassza a folyamatok lehetőséget a bal oldali menüben, majd válassza a Folyamat létrehozása lehetőséget.

1. A "Csatlakozás" lapon válassza a "GitHub" (YAML-fájl) lehetőséget.
2. Ha a rendszer kéri a GitHub-hozzáférés engedélyezését, adja meg a GitHub hitelesítő adatait, és hagyja jóvá az Azure Pipelines hozzáférését a kért jogosultságokkal.
3. A "Kiválasztás" lapon válassza ki a sablont tartalmazó GitHub-adattárat.
4. Válassza a Folyamat konfigurálása lehetőséget a Leltár lapon.
5. A "Konfigurálás" lapon válassza a "Meglévő Azure Pipelines YAML-fájl" használatát.
6. Az elérési úton válassza a "/azuredevops/provision.yml" lehetőséget
7. A Folytatás gombra kattintva lépjen a Véleményezés lapra, és tekintse át a folyamatot.

A "Folyamat YAML áttekintése" képernyőn vizsgáljuk meg azt a Yaml-fájlt, amelyet a folyamat létrehozásához használunk.

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)

Vizsgáljuk meg a konfigurációban használt mezők némelyikét:

• serviceConnection: A korábban beállított Azure PipeLine-szolgáltatáskapcsolat
• command: Your Terraform workflow command: init or apply
• backendAzure: A csoportkörnyezetben a megosztott állapot tárolásához szükséges mezők.\

A folyamat mentése és futtatása előtt hozzá kell adnunk a szolgáltatáskapcsolathoz kötődő változót:

1. Válassza ki a változókat (jobb felső sarokban), és adjon hozzá egy "serviceConnection" nevű változót a szolgáltatáskapcsolat neveként megadott értékkel.
2. A változó mentéséhez kattintson az OK gombra (a jobb alsó sarokban).

Végül válassza a "futtatás" lehetőséget (jobb felső sarokban) a folyamat mentéséhez és futtatásához

Kísérje figyelemmel a folyamat futását

A Feladatok területen kövesse nyomon a buildelési folyamatot az egyes lépéseken keresztül.

A folyamat futása közben figyelje meg az első Terraform init szakaszt, majd a második alkalmazási szakaszt, lépjen a kékről (futó) a zöldre (befejezve). Kiválaszthatja a folyamat működés közbeni megtekintéséhez szükséges fázisokat.

Tipp.

Nézze meg az e-mailjeit. Lehet, hogy már kapott buildértesítést a futtatás eredményeivel. Ezekkel az értesítésekkel megállapíthatja, hogy az egyes buildek sikeresek vagy sikertelenek-e.

Következő lépések

A következő gyakorlatban az Azure Pipelines használatával fogja létrehozni és üzembe helyezni a Spring Boot-mintaalkalmazást.