Partager via

Tutoriel : Traiter des images à l’aide de FFmpeg sur un partage Azure Files monté

Dans ce tutoriel, vous déployez une application Python qui utilise un fichier binaire ffmpeg sur un partage Azure Files monté pour traiter des images dans Azure Functions. Lorsque vous chargez une image dans le conteneur, la fonction se déclenche, appelle ffmpeg à partir du montage pour convertir l’image et enregistre le résultat dans le stockage. By hosting large binaries like ffmpeg on a mounted share instead of in your deployment package, you keep deployments small and cold starts fast.

Dans ce tutoriel, vous allez :

  • Déployez une application de fonction Flex Consumption avec un partage Azure Files monté en utilisant Azure Developer CLI.
  • Charger un exemple d’image pour déclencher un traitement basé sur des blobs
  • Vérifiez que la fonction appelée ffmpeg depuis le montage a enregistré l’image convertie

Note

Les exemples de code de cet article sont disponibles dans le référentiel GitHub Azure Functions Flex Consumption avec des exemples de montage de système d’exploitation Azure Files .

Prerequisites

Les exemples CLI de ce tutoriel utilisent la syntaxe Bash et sont testés dans les terminaux Azure Cloud Shell (Bash) et Linux/macOS.

Initialiser l’exemple de projet

L’exemple de code de ce tutoriel se trouve dans le référentiel GitHub d’exemples de montage du système d’exploitation Azure Files avec Azure Functions Flex Consumption . Le ffmpeg-image-processing dossier contient le code de l’application de fonction, un modèle Bicep qui provisionne les ressources Azure requises et un script post-déploiement qui charge le fichier binaire ffmpeg.

  1. Ouvrez un terminal et accédez au répertoire dans lequel vous souhaitez cloner le référentiel.

  2. Clonez le référentiel :

    git clone https://github.com/Azure-Samples/Azure-Functions-Flex-Consumption-with-Azure-Files-OS-Mount-Samples.git

  3. Accédez au dossier du projet :

    cd Azure-Functions-Flex-Consumption-with-Azure-Files-OS-Mount-Samples/ffmpeg-image-processing

  4. Initialisez l’environnement azd . Lorsque vous y êtes invité, entrez un nom d’environnement tel que ffmpeg-processing:

    azd init

Vérifier le code

Les trois éléments clés qui effectuent le travail de traitement basé sur le montage du système d’exploitation sont l’infrastructure qui crée le montage, le script qui charge le binaire et le code de fonction qui l’appelle.

Le module mounts.bicep configure un montage SMB Azure Files sur l’application de fonction. La mountPath valeur détermine le chemin d’accès local où les fichiers apparaissent au moment de l’exécution. Vous transmettez la clé d’accès du compte de stockage en tant que paramètre et la plateforme la résout au moment de l’exécution via une référence Key Vault :

@description('Function app name')
param functionAppName string

@description('Storage account name')
param storageAccountName string

@description('Storage account access key or app setting reference for Azure Files SMB mount')
param accessKey string

@description('Array of mount configurations')
param mounts array

// Function app reference
resource functionApp 'Microsoft.Web/sites@2023-12-01' existing = {
  name: functionAppName
}

// Azure Files OS mount configuration
// Deploys azureStorageAccounts site config with all mounts in one shot
resource mountConfig 'Microsoft.Web/sites/config@2023-12-01' = {
  parent: functionApp
  name: 'azurestorageaccounts'
  properties: reduce(mounts, {}, (cur, mount) => union(cur, {
    '${mount.name}': {
      type: 'AzureFiles'
      shareName: mount.shareName
      mountPath: mount.mountPath
      accountName: storageAccountName
      accessKey: accessKey
    }
  }))
}

output mountPaths array = [for mount in mounts: mount.mountPath]

Étant donné que les montages SMB Azure Files ne prennent pas encore en charge l’authentification d’identité managée, vous avez besoin d’une clé de compte de stockage. Comme meilleure pratique, stockez cette clé dans Azure Key Vault et utilisez une référence Key Vault dans un paramètre d’application. La configuration de montage fait référence à ce paramètre d’application en utilisant @AppSettingRef(), afin que la clé n’apparaisse jamais dans les modèles Bicep. le keyvault.bicep module crée le coffre-fort, stocke la clé et attribue des rôles RBAC :

@description('Key Vault name')
param name string

@description('Location')
param location string

@description('Tags')
param tags object = {}

@description('Storage account name')
param storageAccountName string

@description('Principal ID of the function app identity (receives Key Vault Secrets User role)')
param functionAppPrincipalId string

@description('Principal ID of the deploying user (receives Key Vault Secrets Officer role)')
param deployerPrincipalId string = ''

// Storage account reference
resource storage 'Microsoft.Storage/storageAccounts@2023-05-01' existing = {
  name: storageAccountName
}

// Key Vault with RBAC authorization
resource keyVault 'Microsoft.KeyVault/vaults@2023-07-01' = {
  name: name
  location: location
  tags: tags
  properties: {
    sku: {
      family: 'A'
      name: 'standard'
    }
    tenantId: tenant().tenantId
    enableRbacAuthorization: true
    enabledForTemplateDeployment: true
    enableSoftDelete: true
    softDeleteRetentionInDays: 7
  }
}

// Store storage account key as a secret (Azure Files mounts require shared key)
resource storageKeySecret 'Microsoft.KeyVault/vaults/secrets@2023-07-01' = {
  parent: keyVault
  name: 'storageAccountKey'
  properties: {
    value: storage.listKeys().keys[0].value
    contentType: 'Storage account access key for Azure Files SMB mount'
  }
}

// Built-in Key Vault RBAC role IDs
var roles = {
  KeyVaultSecretsOfficer: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'b86a8fe4-44ce-4948-aee5-eccb2c155cd7')
  KeyVaultSecretsUser: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '4633458b-17de-408a-b874-0445c86b69e6')
}

// Grant the function app identity read access to secrets
resource functionAppSecretsUser 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(keyVault.id, functionAppPrincipalId, roles.KeyVaultSecretsUser)
  scope: keyVault
  properties: {
    roleDefinitionId: roles.KeyVaultSecretsUser
    principalId: functionAppPrincipalId
    principalType: 'ServicePrincipal'
  }
}

// Grant the deployer manage access to secrets
resource deployerSecretsOfficer 'Microsoft.Authorization/roleAssignments@2022-04-01' = if (!empty(deployerPrincipalId)) {
  name: guid(keyVault.id, deployerPrincipalId, roles.KeyVaultSecretsOfficer)
  scope: keyVault
  properties: {
    roleDefinitionId: roles.KeyVaultSecretsOfficer
    principalId: deployerPrincipalId
    principalType: 'User'
  }
}

output name string = keyVault.name
output uri string = keyVault.properties.vaultUri
output storageKeySecretUri string = storageKeySecret.properties.secretUri

Le main.bicep fichier appelle les modules montage et Key Vault :


// Key Vault for secure storage of Azure Files access key
module keyVault './app/keyvault.bicep' = {
  name: 'keyVault'
  scope: rg
  params: {
    name: !empty(keyVaultName) ? keyVaultName : '${abbrs.keyVaultVaults}${resourceToken}'
    location: location
    tags: tags
    storageAccountName: storage.outputs.name
    functionAppPrincipalId: processorIdentity.outputs.principalId
    deployerPrincipalId: principalId
  }
}

// Azure Files mount configuration (access key resolved via Key Vault reference)
module azureFilesMount './app/mounts.bicep' = {
  name: 'azureFilesMount'
  scope: rg
  params: {
    functionAppName: functionApp.outputs.name
    storageAccountName: storage.outputs.name
    accessKey: '@AppSettingRef(MOUNT_SECRET_REFERENCE)'
    mounts: [
      {
        name: 'tools'
        shareName: 'tools'
        mountPath: '/mounts/tools/'
      }
    ]
  }
  dependsOn: [
    functionAppRoleAssignments
  ]
}

Déployer à l’aide d’Azure Developer CLI

Cet exemple est un modèle Azure Developer CLI (azd). Une seule azd up commande provisionne l’infrastructure, déploie le code de fonction, charge le fichier binaire ffmpeg dans Azure Files et crée l’abonnement Event Grid pour les déclencheurs d’objets blob.

  1. Connectez-vous à Azure. Le script post-déploiement utilise des commandes Azure CLI. Vous devez donc vous authentifier à l’aide des deux outils :

    azd auth login
az login

  2. Provisionnez et déployez tout :

    azd up

    Lorsque vous y êtes invité, sélectionnez l’abonnement Azure et l’emplacement à utiliser. Commande suivante :

    • Crée un groupe de ressources, un compte de stockage, Key Vault, une application de fonction Flex Consumption, une instance Application Insights et une identité managée.
    • Déploie le code de la fonction Python.
    • Télécharge et charge le fichier binaire ffmpeg dans le partage Azure Files.
    • Crée un abonnement Event Grid afin que les téléchargements de blobs déclenchent votre fonction.
    • Exécute un contrôle d’intégrité.

    Note

    Étant donné que les montages SMB Azure Files ne prennent pas encore en charge l’authentification d’identité managée, une clé de compte de stockage est requise. Comme meilleure pratique, le déploiement stocke cette clé dans Azure Key Vault et utilise une référence Key Vault afin que la clé ne soit jamais exposée dans les paramètres de l’application. Cette approche fournit une gestion centralisée des secrets, un audit centralisé, ainsi que le support pour la rotation des clés.

    Le déploiement prend quelques minutes. Une fois l’opération terminée, vous voyez un résumé des ressources créées.

  3. Enregistrez les noms de ressources en tant que variables d’interpréteur de commandes pour les étapes restantes :

    RESOURCE_GROUP=$(azd env get-value AZURE_RESOURCE_GROUP)
STORAGE_ACCOUNT=$(azd env get-value AZURE_STORAGE_ACCOUNT_NAME)
FUNCTION_APP_NAME=$(azd env get-value AZURE_FUNCTION_APP_NAME)
INPUT_CONTAINER=$(azd env get-value AZURE_STORAGE_INPUT_CONTAINER)
OUTPUT_CONTAINER=$(azd env get-value AZURE_STORAGE_OUTPUT_CONTAINER)

Traiter une image

  1. Chargez l’exemple d’image inclus dans le référentiel dans le conteneur d’entrée. L’abonnement Event Grid créé pendant le déploiement déclenche automatiquement votre fonction lorsqu’un objet blob est chargé.

    az storage blob upload \
  --container-name $INPUT_CONTAINER \
  --name sample_image.png \
  --file sample_image.png \
  --account-name $STORAGE_ACCOUNT \
  --auth-mode login

    Conseil / Astuce

    Si le déclencheur ne se déclenche pas immédiatement, attendez 10 à 15 secondes, puis vérifiez les journaux d’exécution de la fonction dans le portail Azure.

  2. Vérifiez que la fonction a traité l’image en répertoriant les objets blob dans le conteneur de sortie :

    az storage blob list \
  --container-name $OUTPUT_CONTAINER \
  --account-name $STORAGE_ACCOUNT \
  --auth-mode login \
  -o table

    Vous devez voir sample_image.jpg dans le conteneur de sortie.

  3. Téléchargez l’image convertie :

    az storage blob download \
  --container-name $OUTPUT_CONTAINER \
  --name sample_image.png \
  --file ./output_image.png \
  --account-name $STORAGE_ACCOUNT \
  --auth-mode login

Note

La première exécution peut être légèrement plus lente (démarrage à froid). Les appels suivants sont plus rapides, car le conteneur de fonctions reste chaud et ffmpeg est mis en cache. Pour réduire les démarrages à froid, envisagez d’activer des instances toujours prêtes.

Nettoyer les ressources

Pour éviter les frais en cours, supprimez toutes les ressources créées par ce tutoriel :

azd down --purge

Avertissement

Cette commande supprime le groupe de ressources et toutes les ressources qu’il contient, notamment l’application de fonction, le compte de stockage et l’instance Application Insights.

Contenu connexe

  • Last updated on