Ü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.
Arbeitsablauf
Innerhalb des Projektverzeichnisses für das von Ihnen erstellte Repository wird ein Verzeichnis namens Terraform und darin eine Datei namens main.tf angezeigt.
Schauen wir uns einige Abschnitte an, die Sie verwenden können, um die Konfiguration Ihres Moduls zu definieren:
- Anbieter: Eine Terraform-Konfigurationsdatei beginnt mit der Spezifikation 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 aus vorhandenen Diensten ab.
- Locals: Generiert neue Variablen mithilfe von Funktionen und Ausdrücken.
- Ressource: Beschreibt Ressourcen und Abhängigkeiten.
- Modul: Wiederverwendbarkeit und Komplexitätsstraktion.
Um unsere Anwendung und Datenbank bereitzustellen, müssen wir nur die Abschnitte "Anbieter " und "Ressource " einschließen.
Öffnen Sie als Nächstes die main.tf Datei, und überprüfen Sie die Gliederung und 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 <"yourServicePrincipalName> " durch den 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
Um die geheimen Schlüssel zu speichern, wechseln Sie zu Ihrem verzweigten GitHub-Repository, wählen Sie "Einstellungen" und dann " Geheimnisse und Variablen" und 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
Innerhalb Ihres Projektverzeichnisses handelt es sich um ein Verzeichnis namens ".github/workflows " und darin eine Datei namens main.yml.
Die main.yml-Datei ist ein GitHub-Workflow. Er verwendet das Geheimnis, das Sie gerade konfiguriert haben, um Ihre Anwendung in Ihrem Azure-Abonnement bereitzustellen.
In der main.yml-Workflowdatei finden Sie 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.
- Die Konfiguration wird ausgelöst, wenn Sie Dateien im Terraform-Verzeichnis aktualisieren.
Hinweis
Sie können den GitHub-Aktionsworkflow auch auslösen, indem Sie zu "Aktionen" wechseln, den Terraform-Workflow auswählen und vorhandene Aufträge erneut ausführen.
Auslösen des Workflows
Lösen Sie in Ihrem Repository als Nächstes Ihre GitHub-Aktion aus, indem Sie Folgendes tun:
Bearbeiten Sie im integrierten GitHub-Text-Editor oder in einem Editor Ihrer Wahl terraform/variables.tf 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 "Aktionen" und dann im linken Bereich den TERRAFORM-Workflow aus.
Überprüfen Sie in der Liste der Schritte, ob Terraform Init, Terraform Plan und Terraform Validate ausgelöst wurden.
Erweitern Sie in der Liste der Schritte Terraform Anwenden, 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 im integrierten GitHub-Text-Editor oder in einem Editor Ihrer Wahl terraform/variables.tf 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 und dann "Neues Projekt" aus.
Geben Sie die folgenden Parameter an.
Parameter Beschreibung Projektname Erforderlich Beschreibung Wahlfrei Sichtbarkeit Privat auswählen Erweitert Versionskontrolle Wählen Sie GIT aus Arbeitselementprozess Wählen Sie "Einfach" aus. 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 die Seite "Dienstverbindungen " auf der Seite "Projekteinstellungen"
Wählen Sie "Dienstverbindung erstellen " und dann "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 Abonnement 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 die Verbindung zu erstellen.
Erstellen der Bereitstellungspipeline
Wichtig
Die Voraussetzungen dieses Moduls erfordern die Installation der Terraform Azure Pipelines-Erweiterung. 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.
Wechseln Sie in Azure DevOps zu Ihrem Projekt, wählen Sie "Pipelines " im linken Menü und 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 YaML-Datei für Azure-Pipelines" zu verwenden.
- Wählen Sie im Pfad „/azuredevops/provision.yml“ aus
- Wählen Sie "Weiter" , um zur Registerkarte " Überprüfen " zu wechseln und Ihre Pipeline zu überprüfen.
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
- befehl: Ihr Terraform-Workflowbefehl: init oder apply
- backendAzure: Benötigte Felder, die in einer Teamumgebung zum Speichern des gemeinsamen Zustands erforderlich sind.
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 namens "serviceConnection" mit dem Wert als Namen Ihrer Dienstverbindung hinzu.
- Wählen Sie OK (untere rechte Ecke) aus, um die Variable zu speichern.
Wählen Sie schließlich "Ausführen" (obere rechte Ecke) aus, 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.
Während Ihre Pipeline läuft, beobachten Sie, wie Ihre erste Terraform-Phase initialisieren und dann die zweite Stufe anwenden von blau (in Ausführung) auf grün (abgeschlossen) wechseln. Sie können die Phasen auswählen, um ihre Pipeline in Aktion zu sehen.
Tipp
Prüfen Sie Ihren Posteingang. Vielleicht haben Sie 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.