Schnellstart: Skalierungsdienste, die mit azd Python-Webvorlagen mit Bicep bereitgestellt werden

Artikel
12/16/2024

Mit den Python-Webvorlagen azd können Sie schnell eine neue Webanwendung erstellen und in Azure bereitstellen. Die azd Vorlagen wurden entwickelt, um kostengünstige Azure-Dienstoptionen zu verwenden. Zweifellos möchten Sie die Serviceebenen (oder Skus) für jeden der in der Vorlage für Ihr Szenario definierten Dienste anpassen.

In dieser Schnellstartanleitung aktualisieren Sie die entsprechenden Bicep-Vorlagendateien, um vorhandene Dienste zu skalieren und ihrer Bereitstellung neue Dienste hinzuzufügen. Anschließend führen Sie den azd provision Befehl aus und zeigen die Änderung an der Azure-Bereitstellung an.

Voraussetzungen

Azure-Abonnement: Kostenloses Azure-Konto

Auf Ihrem lokalen Computer muss Folgendes installiert sein:

Azure Developer CLI
Docker Desktop
Visual Studio Code
Dev-Containererweiterung
Visual Studio Code Bicep Diese Erweiterung hilft Ihnen beim Erstellen der Bicep-Syntax.

Bereitstellen einer Vorlage

Zunächst benötigen Sie eine funktionierende azd Bereitstellung. Sobald Sie dies eingerichtet haben, können Sie die von der azd Vorlage generierten Bicep-Dateien ändern.

Führen Sie die Schritte 1 bis 7 im Schnellstartartikel aus. Verwenden Sie in Schritt 2 die azure-django-postgres-flexible-appservice Vorlage. Aus Gründen Der Einfachheit halber finden Sie hier die gesamte Abfolge von Befehlen, die sie über die Befehlszeile ausstellen müssen:
```
mkdir azdtest
cd azdtest
azd init --template azure-django-postgres-flexible-appservice
azd auth login
azd up
```
Öffnen azd up Sie nach Abschluss die Azure-Portal, navigieren Sie zu dem Azure-App Dienst, der in Ihrer neuen Ressourcengruppe bereitgestellt wurde, und notieren Sie sich den App Service-Preisplan (siehe Seite "Übersicht" des App Service-Plans, Abschnitt "Essentials", Wert "Preisplan").
In Schritt 1 des Schnellstartartikels wurden Sie angewiesen, den Azdtest-Ordner zu erstellen. Öffnen Sie diesen Ordner in Visual Studio Code.
Navigieren Sie im Explorer-Bereich zum Infrastrukturordner . Beobachten Sie die Unterordner und Dateien im Infrastrukturordner .

Die Datei Standard.bicep koordiniert die Erstellung aller dienste, die beim Ausführen einer azd up oder mehrerer azd provisionDienste bereitgestellt werden. Sie ruft andere Dateien auf, z . B. db.bicep und web.bicep, wodurch wiederum Dateien aufgerufen werden, die im Unterordner "\core " enthalten sind.

Der \core-Unterordner ist eine tief geschachtelte Ordnerstruktur, die Bicep-Vorlagen für viele Azure-Dienste enthält. Auf einige dateien im \core-Unterordner werden von den drei Bicep-Dateien der obersten Ebene (Standard.bicep, db.bicep und web.bicep) verwiesen, und einige werden in diesem Projekt überhaupt nicht verwendet.

Skalieren eines Diensts durch Ändern der Bicep-Eigenschaften

Sie können eine vorhandene Ressource in Ihrer Bereitstellung skalieren, indem Sie die SKU ändern. Um dies zu veranschaulichen, ändern Sie den App Service-Plan aus dem "Standard service plan" (der für Apps mit niedrigeren Datenverkehrsanforderungen entwickelt wurde und keine erweiterten Funktionen für die automatische Skalierung und die Datenverkehrsverwaltung benötigt) in den "Standard service plan", der für die Ausführung von Produktionsworkloads entwickelt wurde.

Hinweis

Nicht alle SKU-Änderungen können nach der Tatsache vorgenommen werden. Einige Untersuchungen sind möglicherweise erforderlich, um Ihre Skalierungsoptionen besser zu verstehen.

Öffnen Sie die Datei "web.bicep ", und suchen Sie die appService Moduldefinition. Suchen Sie insbesondere nach der Eigenschaftseinstellung:
```
   sku: {
      name: 'B1'
   }
```
Ändern Sie den Wert wie folgt:B1 S1
```
   sku: {
      name: 'S1'
   }
```
Wichtig

Aufgrund dieser Änderung nimmt der Preis pro Stunde leicht zu. Details zu den verschiedenen Serviceplänen und den zugehörigen Kosten finden Sie auf der App Service-Preisseite.
Wenn Sie die Anwendung bereits in Azure bereitgestellt haben, verwenden Sie den folgenden Befehl, um Änderungen an der Infrastruktur bereitzustellen, ohne den Anwendungscode selbst erneut bereitzustellen.
```
azd provision
```
Sie sollten nicht zur Eingabe eines Standorts und Abonnements aufgefordert werden. Diese Werte werden in der Datei ".azure<environment-name.env>" gespeichert. <environment-name> Dabei handelt es sich um den Umgebungsnamen, den Sie während azd initder Datei angegeben haben.
Wenn azd provision der Vorgang abgeschlossen ist, vergewissern Sie sich, dass Ihre Webanwendung noch funktioniert. Suchen Sie außerdem den App-Serviceplan für Ihre Ressourcengruppe, und bestätigen Sie, dass der Preisplan auf den Standarddienstplan (S1) festgelegt ist.

Hinzufügen einer neuen Dienstdefinition mit Bicep

Sie können Ihrer Bereitstellung eine neue Ressource hinzufügen, indem Sie größere Änderungen an der Bicep im Projekt vornehmen. Um dies zu veranschaulichen, fügen Sie Ihrer vorhandenen Bereitstellung eine Instanz von Azure Cache for Redis hinzu, um eine fiktive neue Funktion vorzubereiten, die Sie zu einem späteren Zeitpunkt hinzufügen möchten.

Wichtig

Aufgrund dieser Änderung bezahlen Sie für eine Instanz von Azure Cache für Redis, bis Sie die Ressource im Azure-Portal löschen oder verwendenazd down. Details zu den verschiedenen Serviceplänen und den damit verbundenen Kosten finden Sie auf der Azure Cache for Redis-Preisseite.

Erstellen Sie eine neue Datei im Infrastrukturordner mit dem Namen "redis.bicep". Kopieren Sie den folgenden Code, und fügen Sie ihn in die neue Datei ein:

param name string
param location string = resourceGroup().location
param tags object = {}
param keyVaultName string
param connStrKeyName string
param passwordKeyName string
param primaryKeyKeyName string

@allowed([
  'Enabled'
  'Disabled'
])
param publicNetworkAccess string = 'Enabled'

@allowed([
  'C'
  'P'
])
param skuFamily string = 'C'

@allowed([
  0
  1
  2
  3
  4
  5
  6
])
param skuCapacity int = 1
@allowed([
  'Basic'
  'Standard'
  'Premium'
])
param skuName string = 'Standard'

param saveKeysToVault bool = true

resource redis 'Microsoft.Cache/redis@2020-12-01' = {
  name: name
  location: location
  properties: {
    sku: {
      capacity: skuCapacity
      family: skuFamily
      name: skuName
    }
    publicNetworkAccess: publicNetworkAccess
    enableNonSslPort: true    
  }
  tags: tags
}

resource keyVault 'Microsoft.KeyVault/vaults@2022-07-01' existing = {
  name: keyVaultName
}

resource redisKey 'Microsoft.KeyVault/vaults/secrets@2022-07-01' = if (saveKeysToVault) {
  name: primaryKeyKeyName
  parent: keyVault
  properties: {
    value: redis.listKeys().primaryKey
  }
}

resource redisConnStr 'Microsoft.KeyVault/vaults/secrets@2018-02-14' = if (saveKeysToVault) {
  name: connStrKeyName
  parent: keyVault
  properties: {
    value: '${name}.redis.cache.windows.net,abortConnect=false,ssl=true,password=${redis.listKeys().primaryKey}'
  }
}
resource redisPassword 'Microsoft.KeyVault/vaults/secrets@2018-02-14' = if (saveKeysToVault) {
  name: passwordKeyName
  parent: keyVault
  properties: {
    value: redis.listKeys().primaryKey
  }
}

output REDIS_ID string = redis.id
output REDIS_HOST string = redis.properties.hostName

Ändern Sie die Datei Standard.bicep, um eine Instanz der "redis"-Ressource zu erstellen.

Fügen Sie in der Datei Standard.bicep den folgenden Code unter den endenden geschweiften geschweiften Klammern hinzu, die dem Abschnitt "Web-Frontend" und oberhalb des Abschnitts "Geheime Schlüssel" zugeordnet sind.

// Caching server
module redis 'redis.bicep' = {
  name: 'redis'
  scope: resourceGroup
  params: {
    name: replace('${take(prefix, 19)}-rds', '--', '-')
    location: location
    tags: tags
    keyVaultName: keyVault.outputs.name
    connStrKeyName: 'RedisConnectionString'
    passwordKeyName: 'RedisPassword'
    primaryKeyKeyName: 'RedisPrimaryKey'
    publicNetworkAccess: 'Enabled'
    skuFamily: 'C'
    skuCapacity: 1
    skuName: 'Standard'
    saveKeysToVault: true
  }
}

Fügen Sie am Ende der Datei Ausgabewerte hinzu:

output REDIS_ID string = redis.outputs.REDIS_ID
output REDIS_HOST string = redis.outputs.REDIS_HOST

Vergewissern Sie sich, dass die gesamte Standard.bicep-Datei mit dem folgenden Code identisch ist:

targetScope = 'subscription'

@minLength(1)
@maxLength(64)
@description('Name which is used to generate a short unique hash for each resource')
param name string

@minLength(1)
@description('Primary location for all resources')
param location string

@secure()
@description('DBServer administrator password')
param dbserverPassword string

@secure()
@description('Secret Key')
param secretKey string

@description('Id of the user or app to assign application roles')
param principalId string = ''

var resourceToken = toLower(uniqueString(subscription().id, name, location))
var prefix = '${name}-${resourceToken}'
var tags = { 'azd-env-name': name }

resource resourceGroup 'Microsoft.Resources/resourceGroups@2021-04-01' = {
  name: '${name}-rg'
  location: location
  tags: tags
}

// Store secrets in a keyvault
module keyVault './core/security/keyvault.bicep' = {
  name: 'keyvault'
  scope: resourceGroup
  params: {
    name: '${take(replace(prefix, '-', ''), 17)}-vault'
    location: location
    tags: tags
    principalId: principalId
  }
}

module db 'db.bicep' = {
  name: 'db'
  scope: resourceGroup
  params: {
    name: 'dbserver'
    location: location
    tags: tags
    prefix: prefix
    dbserverDatabaseName: 'relecloud'
    dbserverPassword: dbserverPassword
  }
}

// Monitor application with Azure Monitor
module monitoring 'core/monitor/monitoring.bicep' = {
  name: 'monitoring'
  scope: resourceGroup
  params: {
    location: location
    tags: tags
    applicationInsightsDashboardName: '${prefix}-appinsights-dashboard'
    applicationInsightsName: '${prefix}-appinsights'
    logAnalyticsName: '${take(prefix, 50)}-loganalytics' // Max 63 chars
  }
}

// Web frontend
module web 'web.bicep' = {
  name: 'web'
  scope: resourceGroup
  params: {
    name: replace('${take(prefix, 19)}-appsvc', '--', '-')
    location: location
    tags: tags
    applicationInsightsName: monitoring.outputs.applicationInsightsName
    keyVaultName: keyVault.outputs.name
    appCommandLine: 'entrypoint.sh'
    pythonVersion: '3.12'
    dbserverDomainName: db.outputs.dbserverDomainName
    dbserverUser: db.outputs.dbserverUser
    dbserverDatabaseName: db.outputs.dbserverDatabaseName
  }
}

// Caching server
module redis 'redis.bicep' = {
  name: 'redis'
  scope: resourceGroup
  params: {
    name: replace('${take(prefix, 19)}-rds', '--', '-')
    location: location
    tags: tags
    keyVaultName: keyVault.outputs.name
    connStrKeyName: 'RedisConnectionString'
    passwordKeyName: 'RedisPassword'
    primaryKeyKeyName: 'RedisPrimaryKey'
    publicNetworkAccess: 'Enabled'
    skuFamily: 'C'
    skuCapacity: 1
    skuName: 'Standard'
    saveKeysToVault: true
  }
}

var secrets = [
  {
    name: 'DBSERVERPASSWORD'
    value: dbserverPassword
  }
  {
    name: 'SECRETKEY'
    value: secretKey
  }
]

@batchSize(1)
module keyVaultSecrets './core/security/keyvault-secret.bicep' = [for secret in secrets: {
  name: 'keyvault-secret-${secret.name}'
  scope: resourceGroup
  params: {
    keyVaultName: keyVault.outputs.name
    name: secret.name
    secretValue: secret.value
  }
}]

output AZURE_LOCATION string = location
output AZURE_KEY_VAULT_ENDPOINT string = keyVault.outputs.endpoint
output AZURE_KEY_VAULT_NAME string = keyVault.outputs.name
output APPLICATIONINSIGHTS_NAME string = monitoring.outputs.applicationInsightsName
output BACKEND_URI string = web.outputs.uri

output REDIS_ID string = redis.outputs.REDIS_ID
output REDIS_HOST string = redis.outputs.REDIS_HOST

Stellen Sie sicher, dass alle Ihre Änderungen gespeichert werden, und verwenden Sie dann den folgenden Befehl, um Ihre bereitgestellten Ressourcen in Azure zu aktualisieren:
```
azd provision
```
Hinweis

Je nach vielen Faktoren kann das Hinzufügen einer Instanz von Azure Cache für Redis zur vorhandenen Bereitstellung sehr lange dauern. Bei Tests haben wir in über 20 Minuten Ausführungszeiten erlebt. Solange keine Fehler angezeigt werden, können Sie den Vorgang bis zum Abschluss fortsetzen.
Öffnen azd provision Sie nach Abschluss des Vorgangs die Azure-Portal, navigieren Sie zur Ressourcengruppe für Ihre Bereitstellung, und bestätigen Sie in der Liste der Dienste, dass Sie jetzt über eine Instanz von Azure Cache für Redis verfügen.

Dies schließt die Schnellstartanleitung ab, es gibt jedoch viele Azure-Dienste, die Ihnen helfen können, skalierbarere und produktionsfähige Anwendungen zu erstellen. Ein guter Ausgangspunkt wäre, um mehr über Azure API Management, Azure Front Door, Azure CDN und Azure Virtual Network zu erfahren, um einige zu nennen.

Bereinigen von Ressourcen

Bereinigen Sie die von der Vorlage erstellten Ressourcen, indem Sie den Befehl "azd down " ausführen.

azd down

Der azd down Befehl löscht die Azure-Ressourcen und den GitHub-Aktionen-Workflow. Wenn Sie dazu aufgefordert werden, stimmen Sie dem Löschen aller Ressourcen zu, die der Ressourcengruppe zugeordnet sind.

Sie können den Azdtest-Ordner auch löschen oder als Grundlage für Ihre eigene Anwendung verwenden, indem Sie die Dateien des Projekts ändern.

Weitere Informationen zu den Python-Webvorlagen azd
Erfahren Sie mehr über die azd Befehle.
Erfahren Sie, was die einzelnen Ordner und Dateien im Projekt tun und was Sie bearbeiten oder löschen können?
Aktualisieren Sie die Bicep-Vorlagen, um Azure-Dienste hinzuzufügen oder zu entfernen. Kennen Sie Bicep nicht? Probieren Sie diesen Lernpfad aus: Grundlagen von Bicep
Dient azd zum Einrichten einer GitHub Actions CI/CD-Pipeline zum erneuten Bereitstellen beim Zusammenführen in Standard Branch
Einrichten der Überwachung, damit Sie Ihre App mithilfe der Azure Developer CLI überwachen können

Freigeben über

Schnellstart: Skalierungsdienste, die mit azd Python-Webvorlagen mit Bicep bereitgestellt werden

Voraussetzungen

Bereitstellen einer Vorlage

Skalieren eines Diensts durch Ändern der Bicep-Eigenschaften

Hinzufügen einer neuen Dienstdefinition mit Bicep

Bereinigen von Ressourcen

Feedback

Zusätzliche Ressourcen

Freigeben über

Schnellstart: Skalierungsdienste, die mit azd Python-Webvorlagen mit Bicep bereitgestellt werden

Voraussetzungen

Bereitstellen einer Vorlage

Skalieren eines Diensts durch Ändern der Bicep-Eigenschaften

Hinzufügen einer neuen Dienstdefinition mit Bicep

Bereinigen von Ressourcen

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen