0Pricing
Cloud & IT Cert Prep · Leçon

Déclencheurs et liaisons Azure Functions

Écrivez une fonction déclenchée par HTTP, ajoutez une liaison de sortie pour écrire dans Azure Queue Storage et comprenez le modèle de mise à l’échelle automatique du plan Consommation.

Déclencheurs et liaisons Azure Functions est une leçon Cloud & IT Cert Prep gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Cloud & IT Cert Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Cloud & IT Cert Prep comprend 4 leçons au total.

Que sont Azure Functions ?

Azure Functions est un service de calcul serverless qui vous permet d’exécuter de petites unités de code (fonctions) en réponse à des événements, sans gérer d’infrastructure. Vous ne payez que le temps d’exécution et la mémoire utilisés pendant l’exécution de votre fonction : aucune facturation n’est appliquée lorsqu’elle est inactive. Functions convient particulièrement aux tâches événementielles, aux API légères, aux tâches planifiées et à l’intégration de services cloud sans serveur persistant.

Déclencheurs : ce qui démarre une fonction

Chaque Azure Function doit posséder exactement un déclencheur qui définit l’événement provoquant son exécution. Les déclencheurs courants comprennent HTTP (requête HTTP entrante), Timer (planification CRON), Blob Storage (nouveau blob dans un conteneur), Queue Storage (nouveau message dans une file d’attente), Event Hub (flux d’événements), Service Bus (message de file d’attente ou de rubrique) et Cosmos DB (flux de modifications). Le déclencheur reçoit les données de l’événement et les transmet au code de votre fonction.

// HTTP trigger function (JavaScript/Node.js)
module.exports = async function (context, req) {
  const name = req.query.name || (req.body && req.body.name);
  const message = name ? 'Hello, ' + name : 'Pass a name in the query or body';
  context.res = {
    status: 200,
    body: { message }
  };
};

Function.json : configuration des déclencheurs et des liaisons

Dans les langages non compilés (JavaScript, Python), un fichier function.json situé dans le répertoire de chaque fonction déclare ses déclencheurs et ses liaisons. Ce fichier associe les sources d’événements et les sorties à des paramètres nommés dans le code de votre fonction. Pour C# et Java, les liaisons sont déclarées directement dans le code à l’aide d’attributs ou d’annotations. L’environnement d’exécution Functions lit la configuration et établit automatiquement les connexions aux services Azure.

// function.json — HTTP trigger + Queue output binding
{
  'bindings': [
    {
      'authLevel': 'function',
      'type': 'httpTrigger',
      'direction': 'in',
      'name': 'req',
      'methods': ['post']
    },
    {
      'type': 'http',
      'direction': 'out',
      'name': 'res'
    },
    {
      'type': 'queue',
      'direction': 'out',
      'name': 'outputQueue',
      'queueName': 'processing-queue',
      'connection': 'AzureWebJobsStorage'
    }
  ]
}

Liaisons de sortie : écrire dans des services

Les liaisons de sortie permettent à votre fonction d’écrire des données dans des services Azure (Blob Storage, Queue Storage, Cosmos DB, Event Hub, etc.) sans gérer de SDK ni de chaînes de connexion. Il vous suffit d’affecter une valeur au paramètre de liaison de sortie, et l’environnement d’exécution Functions gère l’écriture. Cela réduit considérablement le code répétitif et découple votre fonction des détails d’implémentation du service Azure utilisé.

// HTTP trigger with Queue output binding (Node.js)
module.exports = async function (context, req) {
  const orderData = req.body;

  // Write to queue via output binding -- no SDK needed!
  context.bindings.outputQueue = JSON.stringify({
    orderId: orderData.id,
    timestamp: new Date().toISOString()
  });

  context.res = { status: 202, body: 'Order queued' };
};

Déclencheur Timer avec des expressions CRON

Le déclencheur Timer exécute une fonction selon une planification définie par une expression CRON. Azure Functions utilise une expression CRON en 6 parties : {seconds} {minutes} {hours} {day} {month} {day-of-week}. Utilisez 0 0 * * * * pour une exécution toutes les heures, 0 0 0 * * * pour une exécution quotidienne à minuit, ou 0 0 9-17 * * 1-5 pour une exécution toutes les heures pendant les heures ouvrées en semaine. Les fonctions Timer sont utiles pour les tâches de nettoyage, la génération de rapports et les vérifications d’intégrité.

// Timer trigger — runs every day at 02:00 UTC
// function.json binding:
// {
//   'type': 'timerTrigger',
//   'schedule': '0 0 2 * * *',
//   'name': 'myTimer'
// }

module.exports = async function (context, myTimer) {
  const now = new Date().toISOString();
  context.log('Daily cleanup started at', now);
  // ... perform cleanup logic ...
  context.log('Cleanup completed');
};

Plan Consumption : mise à l’échelle serverless

Avec le plan Consumption, Azure Functions adapte automatiquement le nombre d’instances, de zéro à plusieurs centaines, en fonction du débit d’événements déclencheurs. Vous payez uniquement le nombre d’exécutions et les Go-secondes de mémoire consommées : le premier million d’exécutions mensuelles est gratuit. L’hôte Functions peut faire évoluer un déclencheur HTTP jusqu’à 200 instances et un déclencheur de file d’attente jusqu’au nombre de messages de la file traités simultanément. Le démarrage à froid (première exécution après une période d’inactivité) ajoute une brève latence, réduite par les instances préchauffées du plan Premium.

# View billing details for a function app
az functionapp show \
  --name myFunctionApp \
  --resource-group MyRG \
  --query '{name:name, plan:serverFarmId, state:state}'

# Create a Function App on Consumption plan
az functionapp create \
  --name myFunctionApp \
  --resource-group MyRG \
  --consumption-plan-location eastus \
  --runtime node \
  --runtime-version 18 \
  --storage-account mystorageaccount

Plans Premium et Dedicated

Le plan Premium élimine les démarrages à froid en conservant des instances préchauffées, ajoute l’intégration au réseau virtuel et autorise des délais d’expiration d’exécution plus longs (jusqu’à 60 minutes). Le plan Dedicated (App Service) exécute les fonctions sur le même plan App Service que les applications web, ce qui est utile lorsque vous avez besoin de coûts prévisibles ou que vous disposez déjà de ressources de calcul App Service. Choisissez Consumption pour une véritable économie serverless, et Premium pour les fonctions sensibles aux performances ou connectées à un réseau virtuel.

# Create a Function App on Premium plan (EP1)
az functionapp plan create \
  --name MyPremiumPlan \
  --resource-group MyRG \
  --location eastus \
  --sku EP1 \
  --is-linux

az functionapp create \
  --name myFunctionAppPremium \
  --resource-group MyRG \
  --plan MyPremiumPlan \
  --runtime python \
  --runtime-version 3.11 \
  --storage-account mystorageaccount

Déployer Azure Functions

Déployez Azure Functions à l’aide des Azure Functions Core Tools (func azure functionapp publish), de l’extension VS Code, d’un déploiement ZIP via Azure CLI ou d’un pipeline CI/CD dans Azure Pipelines ou GitHub Actions. En production, déployez toujours depuis un pipeline plutôt que depuis le poste d’un développeur, afin de garantir que des versions testées et balisées sont mises en production. L’environnement d’exécution Functions prend également en charge le déploiement dans un conteneur Docker pour contrôler entièrement l’environnement d’exécution.

# Local development: install Core Tools
npm install -g azure-functions-core-tools@4

# Start locally (triggers work against real Azure services)
func start

# Deploy to Azure
func azure functionapp publish myFunctionApp

# Or deploy via Azure CLI (ZIP deploy)
zip -r function.zip . --exclude '.git/*'
az functionapp deployment source config-zip \
  --name myFunctionApp \
  --resource-group MyRG \
  --src function.zip

Paramètres d’application et références Key Vault

Les applications Function stockent leur configuration dans les paramètres d’application ; ceux-ci apparaissent comme des variables d’environnement dans le code de votre fonction. Stockez les chaînes de connexion, les clés d’API et les secrets dans les paramètres d’application. En production, utilisez des références Key Vault afin que la valeur soit stockée dans Key Vault et uniquement référencée par son nom dans le paramètre d’application, ce qui évite d’inclure les secrets dans le portail et les artefacts de déploiement. Activez une identité managée sur l’application Function pour vous authentifier auprès de Key Vault sans identifiants.

# Set application settings
az functionapp config appsettings set \
  --name myFunctionApp \
  --resource-group MyRG \
  --settings \
    STORAGE_CONNECTION='@Microsoft.KeyVault(SecretUri=https://mykv.vault.azure.net/secrets/storage-conn/)' \
    COSMOS_DB_URI='https://mycosmosdb.documents.azure.com'

# In function code, read as normal env var
# const storageConn = process.env['STORAGE_CONNECTION'];

Surveiller Functions avec Application Insights

Azure Functions s’intègre automatiquement à Application Insights lorsque vous fournissez une clé d’instrumentation ou une chaîne de connexion. Chaque exécution de fonction est suivie comme une requête, avec notamment sa durée, sa réussite ou son échec et ses propriétés personnalisées. Utilisez les métriques en temps réel d’Application Insights pour observer les exécutions en temps réel pendant les tests, et le volet Échecs pour diagnostiquer les erreurs à l’aide des traces complètes des exceptions et des appels aux dépendances.

# Connect Application Insights to a Function App
az functionapp config appsettings set \
  --name myFunctionApp \
  --resource-group MyRG \
  --settings \
    APPLICATIONINSIGHTS_CONNECTION_STRING='InstrumentationKey=xxxxxxxx;...'

# Custom telemetry in function code (Node.js)
const appInsights = require('applicationinsights');
appInsights.setup().start();
const client = appInsights.defaultClient;
client.trackEvent({ name: 'OrderProcessed', properties: { orderId: '123' } });

Comportement de la concurrence et de la mise à l’échelle

Pour les fonctions déclenchées par une file d’attente, l’hôte Functions traite plusieurs messages en parallèle. Configurez batchSize dans host.json pour contrôler le nombre de messages traités simultanément par une même instance. Pour les déclencheurs HTTP, la mise à l’échelle horizontale ajoute automatiquement de nouvelles instances. Utilisez maxConcurrentCalls (déclencheurs Service Bus) ou maxPollingInterval (déclencheurs de file d’attente) pour ajuster le débit et éviter de surcharger les services en aval, comme les bases de données, lors des opérations de mise à l’échelle horizontale.

// host.json — tune queue trigger concurrency
{
  'version': '2.0',
  'extensions': {
    'queues': {
      'batchSize': 16,          // messages per instance
      'newBatchThreshold': 8,   // fetch more when < 8 remain
      'maxPollingInterval': '00:00:02',
      'visibilityTimeout': '00:05:00'
    }
  },
  'functionTimeout': '00:10:00'
}

Vérification rapide

Testez votre compréhension des concepts de Microsoft Azure Fundamentals (AZ-900) présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que les déclencheurs définissent l’événement qui démarre une fonction (HTTP, Timer, Queue, Blob, etc.), que les liaisons de sortie permettent aux fonctions d’écrire dans les services Azure sans code SDK, et que le plan Consumption offre une mise à l’échelle véritablement serverless, facturée à chaque exécution, à partir de zéro. Nous allons maintenant découvrir Durable Functions pour les flux de travail avec état.

Questions Fréquemment Posées

La leçon « Déclencheurs et liaisons Azure Functions » est-elle gratuite ?

Oui — le texte complet de « Déclencheurs et liaisons Azure Functions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Cloud & IT Cert Prep, passe à CoddyKit PRO. Le cours Cloud & IT Cert Prep comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Déclencheurs et liaisons Azure Functions » ?

Écrivez une fonction déclenchée par HTTP, ajoutez une liaison de sortie pour écrire dans Azure Queue Storage et comprenez le modèle de mise à l’échelle automatique du plan Consommation. Tu pratiques Cloud & IT Cert Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Cloud & IT Cert Prep ?

Aucune expérience préalable n'est requise. Cloud & IT Cert Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Déclencheurs et liaisons Azure Functions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Cloud & IT Cert Prep ?

Oui. Chaque leçon Cloud & IT Cert Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Déclencheurs et liaisons Azure Functions
  2. Durable Functions pour les flux de travail avec état
  3. Azure Logic Apps
  4. Event Grid et architecture pilotée par les événements
← Retour à Cloud & IT Cert Prep