Übung: Bereitstellen von Azure-Ressourcen
In dieser Übung konfigurieren Sie einen Automatisierungsworkflow zur Bereitstellung Ihrer Terraform-Ressourcen.
Zugriff auf die Beispielanwendung
In dieser Übung erstellen Sie ein GitHub-Repository anhand einer Vorlage, die den gesamten Code für die Terraform-Bereitstellung enthält.
Navigieren Sie auf GitHub zur Hauptseite des Repositorys:
https://github.com/MicrosoftDocs/mslearn-java-petclinic-simplifiedWählen Sie oberhalb der Dateiliste Diese Vorlage verwenden und dann Neues Repository erstellen aus.
Geben Sie im Feld Repositoryname einen eindeutigen Namen für Ihr Repository ein. Achten Sie darauf, die Namenskonvention für GitHub-Repositorys einzuhalten.
Stellen Sie sicher, dass die Option Privat ausgewählt ist, und wählen Sie dann Repository erstellen aus.
Workflow
Im Projektverzeichnis für das soeben erstellte Repository sehen Sie ein Verzeichnis namens terraform und darin eine Datei mit dem Namen main.tf.
Schauen wir uns einige Abschnitte an, die Sie verwenden können, um die Konfiguration Ihres Moduls zu definieren:
- Anbieter: Terraform-Konfigurationsdateien beginnen mit der Angabe des Anbieters. Wenn Sie Azure verwenden, geben Sie den Azure-Anbieter (
azurerm) im Anbieterblock an. - Terraform: Die Terraform-Version, mit der Sie arbeiten
- Daten: Ruft Daten von vorhandenen Diensten ab.
- Lokale Variablen: Generiert neue Variablen unter Verwendung von Funktionen und Ausdrücken.
- Ressource: Beschreibt Ressourcen und Abhängigkeiten.
- Modul: Abstraktion der Wiederverwendbarkeit und Komplexität.
Um unsere Anwendung und Datenbank bereitzustellen, müssen wir nur die Abschnitte Anbieter und Ressource einfügen.
Öffnen Sie als Nächstes die Datei main.tf, und überprüfen Sie die Gliederung und die Kommentare:
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
}
}
Einrichten Ihres GitHub Actions-Workflows mit Terraform
Gewähren Sie nun Ihrem GitHub-Workflow den Zugriff auf Ihr Azure-Konto.
Erstellen Sie in der Azure CLI einen Dienstprinzipal, indem Sie den folgenden Befehl ausführen:
Wichtig
Ersetzen Sie <Ihr Dienstprinzipalname> mit dem Dienstprinzipalnamen, den Sie verwenden möchten.
az ad sp create-for-rbac --name "<yourServicePrincipalName>" --role contributor --scopes /subscriptions/<subscriptionId> --sdk-auth
Der voranstehende Befehl gibt den folgenden JSON-Code zurück. Kopieren Sie diesen zur Verwendung im nächsten Schritt:
{
"clientId": "XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXX",
"clientSecret": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
"subscriptionId": "XXXXXXXXX-XXXXX-XXXX-XXXX-XXXXXXXXXXXXX",
"tenantId": "XXXXXXXX-XXXXX-XXXX-XXXX-XXXXXXXXXXX",
...
}
GitHub-Geheimnisse
Ihr GitHub-Repository verfügt über ein Feature namens „Geheimnisse“, das es Ihnen ermöglichen, vertrauliche Daten zu speichern, die Terraform für die Authentifizierung bei Azure verwendet.
Nachdem Sie im vorangegangenen Schritt die erforderlichen IDs und das Geheimnis erstellt haben, besteht der nächste Schritt in dieser Lerneinheit darin, sie dem Geheimnisspeicher in Ihrem GitHub-Projekt hinzuzufügen.
Für diese Übung müssen Sie die folgenden Geheimnisse speichern:
AZURE_CLIENT_IDAZURE_CLIENT_SECRETAZURE_SUBSCRIPTION_IDAZURE_TENANT_ID
Navigieren Sie zum Speichern der Geheimnisse zu Ihrem verzweigten GitHub-Repository, wählen Sie Einstellungen und dann im linken Bereich Geheimnisse und Variablen aus. Wählen Sie dann Aktionen im linken Bereich aus.
Erstellen Sie vier Geheimnisse mithilfe der Werte, die von der Erstellung des Dienstprinzipals zurückgegeben werden.
Achten Sie darauf, dass Sie die Geheimnisse ohne die Anführungszeichen (" ") speichern, wie im folgenden Screenshot gezeigt:
Workflowdatei
In Ihrem Projektverzeichnis befindet sich ein Verzeichnis namens .github/workflows und darin eine Datei namens main.yml.
Die Datei main.yml ist ein GitHub-Workflow. Er verwendet das Geheimnis, das Sie gerade konfiguriert haben, um Ihre Anwendung in Ihrem Azure-Abonnement bereitzustellen.
Die Workflowdatei main.yml hat den folgenden Inhalt:
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
Dieser Workflow führt die folgenden Aktionen aus:
- Überprüfen der Formatierung der Konfiguration.
- Generieren eines Plans für jeden Pull Request.
- Auslösen der Konfiguration, wenn Dateien im Verzeichnis Terraform aktualisiert werden.
Hinweis
Sie können den GitHub Actions-Workflow auch auslösen, indem Sie zu Aktionen navigieren, den Terraform-Workflow auswählen und dann die Option Vorhandene Aufträge noch mal ausführen verwenden.
Auslösen des Workflows
Lösen Sie in Ihrem Repository als Nächstes Ihre GitHub-Aktion aus, indem Sie Folgendes tun:
Bearbeiten Sie terraform/variables.tf im integrierten GitHub-Texteditor oder in einem Editor Ihrer Wahl wie folgt:
a. Ändern Sie
"CHANGE_ME_RESOURCE_GROUP"in den gewünschten Ressourcengruppennamen.
b. Ändern Sie"CHANGE_ME_APP_NAME"in den gewünschten Anwendungsnamen. Achten Sie darauf, dass Ihr Anwendungsname eindeutig ist.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" }Committen Sie Ihre Änderungen.
Überprüfen des GitHub Actions-Builds
Wählen Sie in Ihrem Repository die Option Aktionen und dann im linken Bereich den Workflow TERRAFORM aus.
Überprüfen Sie in der Liste der Schritte, ob Terraform Init, Terraform Plan und Terraform Validate ausgelöst wurden.
Erweitern Sie Terraform Apply in der Liste der Schritte, und überprüfen Sie Folgendes:
Terraform hat die Ressourcen erstellt und zeigt die URL der Azure-Instanz an.
Ihre Azure-App-Instanz ist öffentlich verfügbar.
Nächste Schritte
In der nächsten Übung verwenden Sie GitHub Actions zum Bereitstellen einer Spring Boot-Beispielanwendung.
Einrichten des Anwendungsnamens und der Azure-Ressourcengruppe
Bearbeiten Sie Ihre Azure-Ressourcennamen in Ihrem GitHub-Repository, indem Sie die folgende Aktion ausführen:
Bearbeiten Sie terraform/variables.tf im integrierten GitHub-Texteditor oder in einem Editor Ihrer Wahl wie folgt:
a. Ändern Sie
"<CHANGE_ME_RESOURCE_GROUP>"in den gewünschten Ressourcengruppennamen.
b. Ändern Sie"<CHANGE_ME_APP_NAME>"in den gewünschten Anwendungsnamen. Achten Sie darauf, dass Ihr Anwendungsname eindeutig ist.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" }Committen Ihrer Änderungen
Erstellen einer Azure-Pipeline zum Bereitstellen Ihrer Terraform-Ressourcen
In unserem Azure DevOps-Projekt erstellen wir zwei separate Pipelines für Provisionierung und Build-and-Deploy. Die Bereitstellungspipeline erstellt die Azure-Ressourcen, die zu einem späteren Zeitpunkt über die Build-and-Deploy-Pipeline freigegeben werden.
Erstellen wir nun die erste Bereitstellungspipeline:
Wählen Sie Ihre Organisation aus und wählen Sie dann Neues Projekt.
Geben Sie die folgenden Parameter an.
Parameter BESCHREIBUNG Projektname Erforderlich Beschreibung Optional Sicht Wählen Sie Privat Erweitert Versionskontrolle Wählen Sie Git Arbeitselementprozess Wählen Sie Basic Wählen Sie Projekt erstellen aus, um das Projekt zu erstellen und eine Willkommensseite zu öffnen.
Einrichten der Azure-Pipeline-Dienstverbindung
Nun geben wir Ihrer Azure-Pipeline Zugriff auf Ihr Azure-Konto.
Öffnen Sie in Azure DevOps auf der Seite mit den Projekteinstellungen die Seite Dienstverbindungen
Wählen Sie Dienstverbindung erstellen und anschließend Azure Resource Manager und dann Weiter aus.
Wählen Sie Dienstprinzipal (automatisch) und dann Weiter aus.
Geben Sie die folgenden Parameter an.
Parameter Beschreibung Bereichsebene Azure-Abonnement auswählen Subscription Auswählen Ihres vorhandenen Azure-Abonnements Ressourcengruppe Lassen Sie die Option leer, damit Benutzer auf alle innerhalb des Abonnements definierten Ressourcen zugreifen können Verbindungsname Erforderlich. Der Name, den Sie verwenden, um in den Aufgaben-Eigenschaften auf diese Dienstverbindung zu verweisen. Dieser Name ist nicht der Name Ihres Azure-Abonnements. Wählen Sie Speichern aus, um das die Verbindung zu erstellen.
Erstellen der Bereitstellungspipeline
Wichtig
Für dieses Modul müssen Sie die Terraform Azure Pipelines-Erweiterung installieren. Wenn Sie sie nicht installiert haben, wird Ihre Pipeline nicht ausgeführt.
Nachdem Sie Ihr Projekt und die Verbindung mit Azure eingerichtet haben, müssen Sie eine Azure-Pipeline zum Bereitstellen Ihrer Terraform-Ressourcen erstellen.
Navigieren Sie in Azure DevOps zu Ihrem Projekt, wählen Sie im Menü auf der linken Seite Pipelines aus, und wählen Sie dann Pipeline erstellen aus.
- Wählen Sie auf der Registerkarte Verbinden die Option GitHub (YAML-Datei) aus.
- Wenn Sie aufgefordert werden, den Zugriff auf GitHub zu autorisieren, geben Sie Ihre GitHub-Anmeldeinformationen ein und genehmigen Sie den Zugriff für Azure Pipelines mit den angeforderten Berechtigungen.
- Wählen Sie auf der Registerkarte Auswählen das GitHub-Repository aus, das Ihre Vorlage enthält.
- Wählen Sie auf der Registerkarte Bestand die Option Pipeline konfigurieren aus.
- Wählen Sie auf der Registerkarte Konfigurieren die Option aus, um eine Vorhandene Azure Pipelines YAML-Datei zu verwenden.
- Wählen Sie im Pfad „/azuredevops/provision.yml“ aus
- Wählen Sie Weiter aus, um die Registerkarte *Überprüfung anzuzeigen, und überprüfen Sie Ihre Pipeline.
Sehen Sie sich auf dem Bildschirm „Überprüfen Sie die YAML-Pipeline“ die YAML-Datei an, die zum Erstellen der Pipeline verwendet wird.
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)
Sehen wir uns einige der Felder an, die in der Konfiguration verwendet werden:
- serviceConnection: Ihre Azure Pipeline-Dienstverbindung, die Sie zuvor eingerichtet haben
- command: der Terraform-Workflow-Befehl Init oder apply
- backendAzure: erforderliche Felder, die in einer Teamumgebung erforderlich sind, um den geteilten Zustand zu speichern
Bevor Sie die Pipeline speichern und ausführen, müssen Sie die Variable hinzufügen, die an die Dienstverbindung gebunden wird:
- Wählen Sie Variablen (oben rechts) aus, und fügen Sie eine Variable mit dem Namen „serviceConnection“ mit dem Wert als Namen Ihrer Dienstverbindung hinzu.
- Wählen Sie OK (unten rechts), um die Variable zu speichern.
Klicken Sie abschließend auf „Ausführen“ (obere rechte Ecke), um die Pipeline zu speichern und auszuführen
Beobachten der Ausführung der Pipeline
Verfolgen Sie als Nächstes den Buildprozess durch die einzelnen Schritte.
Wenn Ihre Pipeline ausgeführt wird, sehen Sie als Erstes die Terraform-Init-Phase und dann die zweite Apply-Phase. Die Farbe wechselt von blau (wird ausgeführt) zu grün (abgeschlossen). Sie können die Phasen auswählen, um ihre Pipeline in Aktion zu sehen.
Tipp
Prüfen Sie Ihren Posteingang. Sie haben möglicherweise bereits eine Buildbenachrichtigung mit den Ergebnissen Ihrer Ausführung erhalten. Sie können Benachrichtigungen wie diese verwenden, um zu ermitteln, ob ein Build erfolgreich verläuft oder fehlschlägt.
Nächste Schritte
In der nächsten Übung verwenden Sie Azure Pipelines, um Ihre Spring Boot-Beispielanwendung zu erstellen und bereitzustellen.