Ćwiczenie — aprowizuj zasoby platformy Azure

Ukończone

W tym ćwiczeniu skonfigurujesz przepływ pracy automatyzacji, aby aprowizować zasoby programu Terraform.

Uzyskiwanie dostępu do przykładowej aplikacji

W tym ćwiczeniu utworzysz repozytorium GitHub na podstawie szablonu zawierającego cały kod aprowizacji narzędzia Terraform.

1. W usłudze GitHub przejdź do strony głównej repozytorium:

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

2. Nad listą plików wybierz pozycję Użyj tego szablonu, a następnie wybierz pozycję Utwórz nowe repozytorium.

   

3. W polu Nazwa repozytorium wprowadź unikatową nazwę repozytorium. Pamiętaj, aby postępować zgodnie z konwencją nazewnictwa dla repozytoriów GitHub.

4. Upewnij się, że wybrano opcję Prywatny , a następnie wybierz pozycję Utwórz repozytorium.

   

Przepływ pracy

W katalogu projektu dla utworzonego repozytorium zobaczysz katalog o nazwie terraform i w nim plik o nazwie main.tf.

Przyjrzyjmy się kilku sekcjam, których można użyć do zdefiniowania konfiguracji modułu:

• Dostawca: plik konfiguracji narzędzia Terraform rozpoczyna się od specyfikacji dostawcy. W przypadku korzystania z platformy Azure należy określić dostawcę platformy Azure (azurerm) w bloku dostawcy.
• Terraform: wersja narzędzia Terraform, z którą pracujesz.
• Dane: pobiera dane z istniejących usług.
• Ustawienia lokalne: generuje nowe zmienne przy użyciu funkcji i wyrażeń.
• Zasób: opisuje zasoby i zależności.
• Moduł: możliwość ponownego użycia i abstrakcja złożoności.

Aby aprowizować naszą aplikację i bazę danych, musimy uwzględnić tylko sekcje Dostawca i Zasób .

Następnie otwórz plik main.tf i przejrzyj konspekt i komentarze:

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

Konfigurowanie przepływu pracy funkcji GitHub Actions za pomocą narzędzia Terraform

Zapewnijmy dostęp przepływu pracy usługi GitHub do konta platformy Azure.

W interfejsie wiersza polecenia platformy Azure utwórz jednostkę usługi, uruchamiając następujące polecenie:

Ważne

Zastąp <wartość yourServicePrincipalName> nazwą główną usługi, której chcesz użyć.

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

Powyższe polecenie zwraca następujący kod JSON. Skopiuj go do użycia w następnym kroku:

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

Wpisy tajne usługi GitHub

Repozytorium GitHub ma funkcję o nazwie Wpisy tajne, w której można przechowywać poufne informacje używane przez narzędzie Terraform do uwierzytelniania na platformie Azure.

Po utworzeniu wymaganych identyfikatorów i wpisu tajnego w poprzednim kroku następnym krokiem w tej lekcji jest dodanie ich do magazynu wpisów tajnych w projekcie GitHub.

W tym ćwiczeniu należy przechowywać następujące wpisy tajne:

• AZURE_CLIENT_ID
• AZURE_CLIENT_SECRET
• AZURE_SUBSCRIPTION_ID
• AZURE_TENANT_ID

Aby zapisać wpisy tajne, przejdź do rozwidlenia repozytorium GitHub, wybierz pozycję Ustawienia, a następnie wybierz pozycję Wpisy tajne i zmienne, a następnie wybierz pozycję Akcje w okienku po lewej stronie.

Utwórz cztery wpisy tajne przy użyciu wartości zwróconych podczas tworzenia jednostki usługi.

Pamiętaj, aby przechowywać wpisy tajne bez cudzysłowów (""), jak pokazano na poniższym zrzucie ekranu:

Plik przepływu pracy

Wewnątrz katalogu projektu znajduje się katalog o nazwie .github/workflows i w nim plik o nazwie main.yml.

Plik main.yml jest przepływem pracy usługi GitHub. Używa wpisu tajnego skonfigurowanego do wdrażania aplikacji w subskrypcji platformy Azure.

W pliku przepływu pracy main.yml znajdziesz następującą zawartość:

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

Ten przepływ pracy wykonuje następujące akcje:

• Sprawdza, czy konfiguracja jest poprawnie sformatowana.
• Generuje plan dla każdego żądania ściągnięcia.
• Wyzwala konfigurację podczas aktualizowania plików w katalogu terraform .

Uwaga

Możesz również wyzwolić przepływ pracy funkcji GitHub Actions, przechodząc do pozycji Akcje, wybierając przepływ pracy narzędzia Terraform i wybierając pozycję Uruchom ponownie istniejące zadania.

Wyzwalanie przepływu pracy

Następnie w repozytorium wyzwól akcję usługi GitHub, wykonując następujące czynności:

1. W wbudowanym edytorze tekstów usługi GitHub lub w wybranym edytorze edytuj plik terraform/variables.tf w następujący sposób:

   a. Zmień "CHANGE_ME_RESOURCE_GROUP" nazwę na nazwę zamierzonej grupy zasobów.
   b. Zmień "CHANGE_ME_APP_NAME" nazwę aplikacji na przeznaczoną. Upewnij się, że nazwa aplikacji jest unikatowa.

   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. Zatwierdź zmiany.

Weryfikowanie kompilacji funkcji GitHub Actions

1. W repozytorium wybierz pozycję Akcje, a następnie wybierz przepływ pracy TERRAFORM w okienku po lewej stronie.

2. Na liście kroków sprawdź, czy program Terraform Init, plan programu Terraform i narzędzie Terraform Validate zostały wyzwolone.

   

3. Na liście kroków rozwiń pozycję Terraform Apply (Zastosuj narzędzie Terraform) i sprawdź, czy:

• Narzędzie Terraform utworzyło zasoby i wyświetla adres URL wystąpienia platformy Azure.

• Wystąpienie aplikacji platformy Azure jest publicznie dostępne.

  

Następne kroki

W następnym ćwiczeniu użyjesz funkcji GitHub Actions do wdrożenia przykładowej aplikacji Spring Boot.

Konfigurowanie nazwy aplikacji i grupy zasobów platformy Azure

W repozytorium GitHub zmodyfikuj nazwy zasobów platformy Azure, wykonując następującą akcję:

1. W wbudowanym edytorze tekstów usługi GitHub lub w wybranym edytorze edytuj plik terraform/variables.tf w następujący sposób:

   a. Zmień "<CHANGE_ME_RESOURCE_GROUP>" nazwę na nazwę zamierzonej grupy zasobów.
   b. Zmień "<CHANGE_ME_APP_NAME>" nazwę aplikacji na przeznaczoną. Upewnij się, że nazwa aplikacji jest unikatowa.

   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. Zatwierdzanie zmian

Tworzenie potoku platformy Azure w celu aprowizowania zasobów programu Terraform

W naszym projekcie usługi Azure DevOps utworzymy dwa oddzielne potoki na potrzeby aprowizacji i kompilowania i wdrażania. Potok aprowizacji tworzy zasoby platformy Azure, które zostaną wydane za pośrednictwem potoku kompilacji i wdrażania w późniejszym momencie.

Utwórzmy pierwszy potok aprowizacji:

1. Wybierz organizację, a następnie wybierz pozycję Nowy projekt.

2. Określ następujące parametry.

   Parametr	Opis
   Nazwa projektu	Wymagania
   Opis	Opcjonalnie
   Widoczność	Wybierz pozycję Prywatny
   Zaawansowani
   Kontrola wersji	Wybieranie narzędzia GIT
   Proces elementu roboczego	Wybierz pozycję Podstawowa

3. Wybierz pozycję Utwórz projekt , aby utworzyć projekt i otworzyć stronę powitalną.

Konfigurowanie połączenia usługi Azure Pipeline Service

Nadajmy usłudze Azure Pipeline dostęp do konta platformy Azure.

1. W usłudze Azure DevOps otwórz stronę Połączenia z usługą na stronie ustawień projektu

2. Wybierz pozycję Utwórz połączenie z usługą i wybierz pozycję Azure Resource Manager, a następnie wybierz pozycję Dalej.

3. Wybierz pozycję Jednostka usługi (automatyczna), a następnie wybierz pozycję Dalej.

4. Określ następujące parametry.

   Parametr	Opis
   Poziom zakresu	Wybieranie subskrypcji platformy Azure
   Subskrypcja	Wybierz istniejącą subskrypcję platformy Azure
   Grupa zasobów	Pozostaw wartość pustą, aby umożliwić użytkownikom dostęp do wszystkich zasobów zdefiniowanych w ramach subskrypcji
   Nazwa połączenia	Wymagany. Nazwa używana do odwoływania się do tego połączenia z usługą we właściwościach zadania. Ta nazwa nie jest nazwą subskrypcji platformy Azure.

5. Aby utworzyć połączenie, wybierz Zapisz.

Tworzenie potoku aprowizacji

Ważne

Wymagania wstępne tego modułu wymagają zainstalowania rozszerzenia Terraform Azure Pipelines. Jeśli go nie zainstalowano, potok nie zostanie uruchomiony.

Po skonfigurowaniu projektu i połączenia z platformą Azure należy utworzyć usługę Azure Pipeline, aby aprowizować zasoby terraform.

W usłudze Azure DevOps przejdź do projektu, wybierz pozycję Potoki w menu po lewej stronie, a następnie wybierz pozycję Utwórz potok.

1. Na karcie "Połącz" wybierz pozycję "GitHub" (plik YAML).
2. Jeśli zostanie wyświetlony monit o autoryzowanie dostępu do usługi GitHub, wprowadź poświadczenia usługi GitHub i zatwierdź dostęp dla usługi Azure Pipelines z żądanymi uprawnieniami.
3. Na karcie "Wybierz" wybierz repozytorium GitHub zawierające szablon.
4. Wybierz pozycję Konfiguruj potok na karcie Spis .
5. Na karcie "Konfiguruj" wybierz opcję użycia "Istniejący plik YAML usługi Azure Pipelines".
6. W ścieżce wybierz pozycję "/azuredevops/provision.yml"
7. Wybierz pozycję Kontynuuj , aby przejść do karty Przegląd i przejrzeć potok.

Na ekranie "Przeglądanie potoku YAML" sprawdźmy plik Yaml, który użyjemy do utworzenia potoku.

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)

Przyjrzyjmy się niektórym polam używanym w konfiguracji:

• serviceConnection: Połączenie usługi Azure PipeLine z konfiguracją wcześniej
• polecenie: Polecenie przepływu pracy narzędzia Terraform: inicjowanie lub stosowanie
• backendAzure: wymagane pola w środowisku zespołowym do przechowywania stanu udostępnionego.\

Przed zapisaniem i uruchomieniem potoku należy dodać zmienną, która będzie wiązać się z połączeniem usługi:

1. Wybierz pozycję Zmienne (w prawym górnym rogu) i dodaj zmienną o nazwie "serviceConnection" z wartością jako nazwą połączenia z usługą.
2. Wybierz przycisk OK (prawy dolny róg), aby zapisać zmienną.

Na koniec wybierz pozycję "Uruchom" (prawy górny róg), aby zapisać i uruchomić potok

Obejrzyj przebieg potoku

W obszarze Zadania prześledzić proces kompilacji za pomocą każdego z kroków.

W miarę uruchamiania potoku obejrzyj pierwszy etap inicjowania narzędzia Terraform, a następnie drugi etap stosowania przejdź od niebieskiego (uruchomionego) do zielonego (ukończono). Możesz wybrać etapy, aby obserwować działanie potoku.

Napiwek

Odbierz pocztę e-mail. Być może otrzymano już powiadomienie o kompilacji z wynikami przebiegu. Możesz użyć tych powiadomień, aby dowiedzieć się, czy każda kompilacja przechodzi pomyślnie, czy kończy się niepowodzeniem.

Następne kroki

W następnym ćwiczeniu użyjesz usługi Azure Pipelines do skompilowania i wdrożenia przykładowej aplikacji Spring Boot.