Dela via

Snabbstart: Skalningstjänster som distribueras med azd Python-webbmallar med Bicep

  • Artikel

Med Python-webbmallarna azd kan du snabbt skapa ett nytt webbprogram och distribuera det till Azure. Mallarna azd har utformats för att använda azure-tjänstalternativ till låg kostnad. Utan tvekan vill du justera tjänstnivåerna (eller sku:erna) för var och en av de tjänster som definierats i mallen för ditt scenario.

I den här snabbstarten uppdaterar du lämpliga bicep-mallfiler för att skala upp befintliga tjänster och lägga till nya tjänster i distributionen. Sedan kör azd provision du kommandot och visar den ändring du gjorde i Azure-distributionen.

Förutsättningar

En Azure-prenumeration – Skapa en kostnadsfritt

Du måste ha följande installerat på den lokala datorn:

Distribuera en mall

Till att börja med behöver du en fungerande azd distribution. När du har det på plats kan du ändra de Bicep-filer som genereras av mallen azd .

  1. Följ steg 1 till 7 i snabbstartsartikeln. I steg 2 använder du mallen azure-django-postgres-flexible-appservice . Här är hela sekvensen med kommandon som ska utfärdas från kommandoraden för enkelhetens skull:

    mkdir azdtest
cd azdtest
azd init --template azure-django-postgres-flexible-appservice
azd auth login
azd up

    När du är azd up klar öppnar du Azure-portalen, navigerar till Azure App Service som har distribuerats i din nya resursgrupp och noterar prisplanen för App Service (se apptjänstplanens översiktssida, essentials-avsnittet "Prisplan"-värde).

  2. I steg 1 i snabbstartsartikeln instruerades du att skapa mappen azdtest . Öppna mappen i Visual Studio Code.

  3. I fönstret Utforskaren navigerar du till mappen infra . Observera undermapparna och filerna i infra-mappen.

    Filen main.bicep samordnar skapandet av alla tjänster som distribueras när du utför en azd up eller azd provision. Den anropar till andra filer, till exempel db.bicep och web.bicep, som i sin tur anropar till filer som finns i undermappen \core .

    Undermappen \core är en djupt kapslad mappstruktur som innehåller bicep-mallar för många Azure-tjänster. Några av filerna i undermappen \core refereras till av de tre bicep-filerna på toppnivå (main.bicep, db.bicep och web.bicep) och vissa används inte alls i det här projektet.

Skala en tjänst genom att ändra dess Bicep-egenskaper

Du kan skala en befintlig resurs i distributionen genom att ändra dess SKU. För att demonstrera detta ändrar du App Service-planen från "Basic Service Plan" (som är utformad för appar med lägre trafikkrav och inte behöver avancerade funktioner för automatisk skalning och trafikhantering) till "Standard Service Plan", som är utformad för att köra produktionsarbetsbelastningar.

Kommentar

Det går inte att göra alla SKU-ändringar i efterhand. Viss forskning kan vara nödvändig för att bättre förstå dina skalningsalternativ.

  1. Öppna filen web.bicep och leta upp moduldefinitionenappService. I synnerhet letar du efter egenskapsinställningen:

       sku: {
      name: 'B1'
   }

    Ändra värdet från B1 till S1 enligt följande:

       sku: {
      name: 'S1'
   }

    Viktigt!

    Som ett resultat av denna förändring kommer priset per timme att öka något. Information om de olika tjänstplanerna och tillhörande kostnader finns på apptjänstens prissida.

  2. Förutsatt att du redan har distribuerat programmet i Azure använder du följande kommando för att distribuera ändringar i infrastrukturen utan att distribuera om själva programkoden.

    azd provision

    Du bör inte uppmanas att ange en plats och prenumeration. Dessa värden sparas i filen .azure<environment-name.env> där <environment-name> är det miljönamn som du angav under azd init.

  3. När azd provision det är klart bekräftar du att webbprogrammet fortfarande fungerar. Leta också upp App Service-planen för resursgruppen och bekräfta att prisplanen är inställd på Standard Service Plan (S1).

Lägga till en ny tjänstdefinition med Bicep

Du kan lägga till en ny resurs i distributionen genom att göra större ändringar i Bicep i projektet. För att demonstrera detta lägger du till en instans av Azure Cache for Redis i din befintliga distribution inför en fiktiv ny funktion som du planerar att lägga till vid ett senare tillfälle.

Viktigt!

Som ett resultat av den här ändringen kommer du att betala för en instans av Azure Cache for Redis tills du tar bort resursen i Azure-portalen eller använder azd down. Information om de olika tjänstplanerna och tillhörande kostnader finns på prissidan för Azure Cache for Redis.

  1. Skapa en ny fil i infra-mappen med namnet redis.bicep. Kopiera och klistra in följande kod i den nya filen:

    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

  2. Ändra filen main.bicep för att skapa en instans av "redis"-resursen.

    I filen main.bicep lägger du till följande kod under de avslutande klammerparenteser som är associerade med webbklientdelen och ovanför avsnittet hemligheter.

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

  3. Lägg till utdatavärden längst ned i filen:

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

  4. Bekräfta att hela filen main.bicep är identisk med följande kod:

    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

  5. Kontrollera att alla ändringar har sparats och använd sedan följande kommando för att uppdatera dina etablerade resurser i Azure:

    azd provision

    Kommentar

    Beroende på många faktorer kan det ta lång tid att lägga till en instans av Azure Cache for Redis i den befintliga distributionen. I testningen upplevde vi körningstider på över 20 minuter. Så länge du inte ser några fel kan du låta processen fortsätta tills den är klar.

  6. När azd provision du är klar öppnar du Azure-portalen, navigerar till resursgruppen för distributionen och i listan över tjänster bekräftas att du nu har en instans av Azure Cache for Redis.

Detta avslutar snabbstarten, men det finns många Azure-tjänster som kan hjälpa dig att skapa mer skalbara och produktionsklara program. Ett bra ställe att börja på är att lära dig mer om Azure API Management, Azure Front Door, Azure CDN och Azure Virtual Network för att nämna några.

Rensa resurser

Rensa resurserna som skapas av mallen genom att köra kommandot azd down .

azd down

Kommandot azd down tar bort Azure-resurserna och GitHub Actions-arbetsflödet. När du uppmanas till det godkänner du att alla resurser som är associerade med resursgruppen tas bort.

Du kan också ta bort mappen azdtest eller använda den som grund för ditt eget program genom att ändra filerna i projektet.

Relaterat innehåll