Inicio rápido: Escalado de servicios implementados con las plantillas web de Python azd mediante Bicep

Artículo
12/16/2024

Las plantillas web azd de Python le permiten crear rápidamente una nueva aplicación web e implementarla en Azure. Las azd plantillas se diseñaron para usar opciones de servicio de Azure de bajo costo. Sin duda, querrá ajustar los niveles de servicio (o sku) para cada uno de los servicios definidos en la plantilla para su escenario.

En este inicio rápido, actualizará los archivos de plantilla de bicep adecuados para escalar verticalmente los servicios existentes y agregará nuevos servicios a la implementación. A continuación, ejecutará el azd provision comando y verá el cambio realizado en la implementación de Azure.

Requisitos previos

Una suscripción a Azure: cree una cuenta gratuita.

Debe tener instalado lo siguiente en el equipo local:

CLI de desarrollo de Azure
Docker Desktop
Visual Studio Code
Extensión del contenedor de desarrollo
Visual Studio Code Bicep Esta extensión le ayuda a crear la sintaxis de Bicep.

Implementación de una plantilla

Para empezar, necesita una implementación en funcionamiento azd . Una vez que lo tenga, podrá modificar los archivos de Bicep generados por la azd plantilla.

Siga los pasos del 1 al 7 del artículo Inicio rápido. En el paso 2, use la azure-django-postgres-flexible-appservice plantilla. Para mayor comodidad, esta es la secuencia completa de comandos que se van a emitir desde la línea de comandos:
```
mkdir azdtest
cd azdtest
azd init --template azure-django-postgres-flexible-appservice
azd auth login
azd up
```
Una vez azd up finalizado, abra Azure Portal, vaya a la App de Azure Service que se implementó en el nuevo grupo de recursos y anote el plan de precios de App Service (consulte la página Información general del plan de App Service, sección Essentials, valor "Plan de precios").
En el paso 1 del artículo inicio rápido, se le indicó que creara la carpeta azdtest . Abra esa carpeta en Visual Studio Code.
En el panel Explorador, vaya a la carpeta infra . Observe las subcarpetas y los archivos de la carpeta infra .

El archivo main.bicep organiza la creación de todos los servicios implementados al realizar o azd up azd provision. Llama a otros archivos, como db.bicep y web.bicep, que a su vez llaman a archivos contenidos en la subcarpeta \core.

La subcarpeta \core es una estructura de carpetas profundamente anidada que contiene plantillas de bicep para muchos servicios de Azure. Algunos de los archivos de la subcarpeta \core son referenciados por los tres archivos bicep de nivel superior (main.bicep, db.bicep y web.bicep) y algunos no se usan en absoluto en este proyecto.

Escalado de un servicio modificando sus propiedades de Bicep

Puede escalar un recurso existente en la implementación cambiando su SKU. Para demostrarlo, cambiará el plan de App Service del "plan de servicio básico" (que está diseñado para aplicaciones con requisitos de tráfico más bajos y no necesita características avanzadas de escalado automático y administración de tráfico) al "plan de servicio estándar", que está diseñado para ejecutar cargas de trabajo de producción.

Nota:

No todos los cambios de SKU se pueden realizar después del hecho. Algunas investigaciones pueden ser necesarias para comprender mejor las opciones de escalado.

Abra el archivo web.bicep y busque la definición del appService módulo. En concreto, busque el valor de la propiedad :
```
   sku: {
      name: 'B1'
   }
```
Cambie el valor de a B1 S1 como se indica a continuación:
```
   sku: {
      name: 'S1'
   }
```
Importante

Como resultado de este cambio, el precio por hora aumentará ligeramente. Puede encontrar detalles sobre los diferentes planes de servicio y sus costos asociados en la página de precios de App Service.
Suponiendo que ya tiene la aplicación implementada en Azure, use el siguiente comando para implementar los cambios en la infraestructura sin volver a implementar el propio código de la aplicación.
```
azd provision
```
No se le debe solicitar una ubicación ni una suscripción. Estos valores se guardan en el archivo .azure<environment-name.env>, donde <environment-name> es el nombre de entorno que proporcionó durante azd init.
Cuando azd provision haya finalizado, confirme que la aplicación web sigue funcionando. Busque también el plan de App Service para el grupo de recursos y confirme que el plan de precios está establecido en el plan de servicio estándar (S1).

Adición de una nueva definición de servicio con Bicep

Puede agregar un nuevo recurso a la implementación realizando cambios más grandes en Bicep en el proyecto. Para demostrarlo, agregará una instancia de Azure Cache for Redis a la implementación existente como preparación para una nueva característica ficticia que planea agregar en una fecha futura.

Importante

Como resultado de este cambio, pagará por una instancia de Azure Cache for Redis hasta que elimine el recurso en Azure Portal o mediante azd down. Puede encontrar detalles sobre los diferentes planes de servicio y sus costos asociados en la página de precios de Azure Cache for Redis.

Cree un nuevo archivo en la carpeta infra denominada redis.bicep. Copie y pegue el código siguiente en el nuevo archivo:

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

Modifique el archivo main.bicep para crear una instancia del recurso "redis".

En el archivo main.bicep , agregue el código siguiente debajo de las llaves finales asociadas a la sección front-end web y encima de la sección secretos .

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

Agregue valores de salida a la parte inferior del archivo:

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

Confirme que todo el archivo main.bicep es idéntico al código siguiente:

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

Asegúrese de que se guardan todos los cambios y, a continuación, use el siguiente comando para actualizar los recursos aprovisionados en Azure:
```
azd provision
```
Nota:

En función de muchos factores, agregar una instancia de Azure Cache for Redis a la implementación existente podría tardar mucho tiempo. En las pruebas, experimentamos tiempos de ejecución superiores a 20 minutos. Siempre que no vea ningún error, permita que el proceso continúe hasta que se complete.
Cuando azd provision finalice, abra Azure Portal, vaya al grupo de recursos de la implementación y, en la lista de servicios, confirme que ahora tiene una instancia de Azure Cache for Redis.

Esto concluye el inicio rápido, pero hay muchos servicios de Azure que pueden ayudarle a crear aplicaciones más escalables y listas para producción. Un excelente punto de partida sería obtener información sobre Azure API Management, Azure Front Door, Azure CDN y Azure Virtual Network, por nombrar algunos.

Limpieza de recursos

Limpie los recursos creados por la plantilla ejecutando el comando azd down .

azd down

El azd down comando elimina los recursos de Azure y el flujo de trabajo de Acciones de GitHub. Cuando se le solicite, acepte eliminar todos los recursos asociados al grupo de recursos.

También puede eliminar la carpeta azdtest o usarla como base para su propia aplicación modificando los archivos del proyecto.

Más información sobre las plantillas web azd de Python
Obtenga más información sobre los azd comandos.
Obtenga información sobre qué hacen cada una de las carpetas y los archivos del proyecto y qué puede editar o eliminar?
Actualice las plantillas de Bicep para agregar o quitar servicios de Azure. ¿No conoces a Bicep? Pruebe esta ruta de aprendizaje: Aspectos básicos de Bicep
Use azd para configurar una canalización de CI/CD de Acciones de GitHub para volver a implementar la combinación en la rama principal.
Configuración de la supervisión para que pueda supervisar la aplicación mediante la CLI para desarrolladores de Azure

Compartir vía

Inicio rápido: Escalado de servicios implementados con las plantillas web de Python azd mediante Bicep

Requisitos previos

Implementación de una plantilla

Escalado de un servicio modificando sus propiedades de Bicep

Adición de una nueva definición de servicio con Bicep

Limpieza de recursos

Comentarios

Recursos adicionales

Compartir vía

Inicio rápido: Escalado de servicios implementados con las plantillas web de Python azd mediante Bicep

Requisitos previos

Implementación de una plantilla

Escalado de un servicio modificando sus propiedades de Bicep

Adición de una nueva definición de servicio con Bicep

Limpieza de recursos

Contenido relacionado

Comentarios

Recursos adicionales