Référence du développeur Go pour Azure Functions

Azure Functions est un service de calcul serverless que vous pouvez utiliser pour exécuter du code piloté par les événements sans provisionner ni gérer l’infrastructure. Le Worker Go vous permet d’écrire Azure Functions en mode natif dans Go, avec une intégration approfondie dans l’écosystème déclencheur Azure Functions.

Ce guide vous aide à :

Comprendre le modèle de programmation Go
Créer et structurer votre code de projet
Utiliser des déclencheurs
Déployez et exécutez votre application localement et dans Azure

Pour en savoir plus sur le développement Azure Functions en général, consultez la documentation de référence pour les développeurs Azure Functions.

Premiers pas

Choisissez l’environnement qui correspond à votre flux de travail et commencez à utiliser Azure Functions pour Go :

Démarrage rapide de la ligne de commande

Prerequisites

Accédez à la version 1.24 ou ultérieure
Azure Functions Core Tools version 4.12 ou ultérieure. Exécutez func --version pour vérifier votre version installée.
Azure CLI version 2.87.0 ou ultérieure, lorsque vous créez des ressources Azure ou déployez des packages sur Azure. Exécutez az version pour vérifier votre version installée.

Modèle de programmation

Le composant worker Go utilise un modèle de programmation axé sur le code. Vous définissez des fonctions serverless et leurs déclencheurs à l’aide de gestionnaires Go idiomatiques.

Point d’entrée

Chaque projet de code Go commence par une fonction main() qui crée un FunctionApp, enregistre des fonctions et démarre le worker :

package main

import (
    "fmt"
    "net/http"

    "github.com/azure/azure-functions-golang-worker/sdk"
    "github.com/azure/azure-functions-golang-worker/worker"
)

func main() {
    app := sdk.FunctionApp()

    app.HTTP("hello", hello,
        sdk.WithMethods("GET", "POST"),
        sdk.WithAuth("anonymous"),
    )

    worker.Start(app)
}

func hello(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    if name == "" {
        name = "world"
    }
    fmt.Fprintf(w, "Hello, %s!", name)
}

Enregistrement de fonction

Inscrivez des fonctions à l’aide de l’API Fluent Builder avec le modèle d’options fonctionnelles. Chaque type de déclencheur a une méthode d’inscription sur l’objet App :

// HTTP trigger
app.HTTP("myHttpFunc", handler,
    sdk.WithMethods("GET", "POST"),
    sdk.WithAuth("anonymous"),
)

// Timer trigger
app.Timer("myTimerFunc", handler,
    sdk.WithSchedule("0 */5 * * * *"),
)

// Azure Cosmos DB trigger
app.CosmosDB("myCosmosFunc", handler,
    sdk.WithDatabase("mydb"),
    sdk.WithContainer("mycontainer"),
    sdk.WithConnection("CosmosDBConnection"),
)

// Azure Queue Storage trigger
app.Queue("myQueueFunc", handler,
    sdk.WithQueueName("myqueue"),
    sdk.WithConnection("AzureWebJobsStorage"),
)

// Azure Service Bus trigger
app.ServiceBusQueue("myServiceBusFunc", handler,
    sdk.WithQueueName("myqueue"),
    sdk.WithConnection("ServiceBusConnection"),
)

// Azure SQL trigger
app.SQL("mySqlFunc", handler,
    sdk.WithTable("dbo.Products"),
    sdk.WithConnection("SqlConnectionString"),
)

// Event Hubs trigger
app.EventHub("myEventHubFunc", handler,
    sdk.WithEventHubName("myeventhub"),
    sdk.WithConnection("EventHubConnection"),
)

// Event Grid trigger
app.EventGrid("myEventGridFunc", handler)

// Blob trigger (extension model)
app.Blob("myBlobFunc", handler,
    sdk.WithPath("mycontainer/{name}"),
    sdk.WithConnection("AzureWebJobsStorage"),
)

Structure du projet

Un projet de code Go pour Azure Functions est un module Go standard. Lorsque vous exécutez func init --worker-runtime go, les fichiers suivants sont générés :

my-function-app/
├── host.json              # Host configuration
├── local.settings.json    # Local settings (connection strings, app settings)
├── go.mod                 # Go module file
├── go.sum                 # Go module checksums
└── main.go                # Entry point with function registrations

host.json

Le host.json fichier contient des options de configuration au niveau de l’hôte. Pour plus d’informations, consultez la référencehost.json.

local.settings.json

Le local.settings.json fichier stocke les paramètres d’application et les chaînes de connexion utilisés pendant le développement local. Ce fichier n'est pas publié dans Azure. Pour en savoir plus, voir Fichier de paramètres locaux.

Triggers

L’agent Go fournit des méthodes d’enregistrement dédiées pour les déclencheurs pris en charge.

Charges utiles de déclencheur typés

La plupart des déclencheurs pris en charge reçoivent leur charge utile en ligne via gRPC. L’hôte Azure Functions sérialise les données de déclenchement dans le message gRPC, et le travailleur les désérialise en valeurs Go typées. Ces déclencheurs ont :

Signatures de gestionnaire typées avec sécurité au moment de la compilation
Aucune dépendance externe au SDK Azure : seul encoding/json est requis
Charges utiles limitées : les documents de flux de modification, les messages et les événements sont des objets discrets et limités à la taille

Déclencheurs pris en charge :

Déclencheur	Signature du gestionnaire	Méthode d’inscription
HTTP	`func(http.ResponseWriter, *http.Request)`	`app.HTTP()`
Timer	`TimerHandler`	`app.Timer()`
Stockage File d'attente Azure (Stockage de files d'attente Azure)	`QueueHandler`	`app.Queue()`
Azure Cosmos DB, une base de données distribuée globale	`func(context.Context, []bindings.CosmosDocument) error`	`app.CosmosDB()`
Azure Service Bus (File d’attente)	`ServiceBusHandler`	`app.ServiceBusQueue()`
Azure Service Bus (Rubrique)	`ServiceBusHandler`	`app.ServiceBusTopic()`
Event Hubs	`EventHubHandler`	`app.EventHub()`
Event Grid	`EventGridHandler`	`app.EventGrid()`
Azure SQL	`func(context.Context, []bindings.SQLChange) error`	`app.SQL()`

Event Hubs et Service Bus prennent également en charge les gestionnaires de lots fortement typés via app.EventHubBatch(), app.ServiceBusQueueBatch(), et app.ServiceBusTopicBatch().

Liaisons de type sdk

Les liaisons de type SDK fournissent un client Kit de développement logiciel (SDK) Azure authentifié au lieu de données de déclenchement sérialisées. Pour Go, les déclencheurs Stockage Blob prennent en charge les liaisons de type du SDK. L’hôte envoie des métadonnées, telles que le nom du conteneur et le chemin du blob, et le worker construit un client avec une portée spécifique à la ressource. Les liaisons de types SDK fournissent :

Injection de client sdk : le gestionnaire reçoit un client prêt à l’emploi
Dépendances isolées : les packages du SDK Azure se trouvent dans triggers/<name>/
Prise en charge de la diffusion en continu : permet de lire des charges utiles volumineuses sans effectuer de mise en mémoire tampon via gRPC

Pour utiliser le type de liaison SDK Stockage Blob, ajoutez une importation vide pour le package déclencheur Blob :

import _ "github.com/azure/azure-functions-golang-worker/triggers/blob"

Déclencheur	Gestionnaire de réception	Méthode d’inscription
Stockage Blob	`*blob.Client`	`app.Blob()`

Exemple de déclencheur Blob

package main

import (
    "context"
    "fmt"
    "io"
    "log"

    "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blob"
    "github.com/azure/azure-functions-golang-worker/sdk"
    _ "github.com/azure/azure-functions-golang-worker/triggers/blob"
    "github.com/azure/azure-functions-golang-worker/worker"
)

func main() {
    app := sdk.FunctionApp()
    app.Blob("processBlobTrigger", processBlob,
        sdk.WithPath("samples-workitems/{name}"),
        sdk.WithConnection("AzureWebJobsStorage"),
    )
    worker.Start(app)
}

func processBlob(ctx context.Context, client *blob.Client) error {
    get, err := client.DownloadStream(ctx, nil)
    if err != nil {
        return fmt.Errorf("download error: %w", err)
    }
    data, _ := io.ReadAll(get.Body)
    get.Body.Close()
    log.Printf("Blob size: %d bytes", len(data))
    return nil
}

Déclencheurs d’hôte génériques

À utiliser app.GenericTrigger() lorsqu’une extension hôte compatible fournit un déclencheur qui ne possède pas de méthode dédiée d’enregistrement Go. Les déclencheurs génériques prennent en charge le texte brut, les tranches d’octets et les types Go compatibles JSON :

app.GenericTrigger("echoTool", echoTool, &bindings.GenericTrigger{
    Type:     "mcpToolTrigger",
    Name:     "call",
    DataType: "string",
    Properties: map[string]any{
        "toolName":       "echo",
        "description":    "Echo text using a generic Go trigger",
        "toolProperties": `[{"propertyName":"text","propertyType":"string","description":"Text to echo","isRequired":true}]`,
    },
})

L’extension hôte compatible doit être installée. L'enregistrement générique des déclencheurs ne fournit pas de gestion HTTP, d'injection client SDK, de relecture Durable Functions, ni de règlement de messages spécifique au service. Pour des exemples complets, voir l’exemple de déclencheurs génériques.

Déclencheurs HTTP

Les gestionnaires de déclencheurs HTTP utilisent des types Go net/http standard, ce qui les rend immédiatement familiers aux développeurs Go :

func myHandler(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    if name == "" {
        name = "world"
    }
    w.Header().Set("Content-Type", "application/json")
    fmt.Fprintf(w, `{"message": "Hello, %s!"}`, name)
}

Inscrire des fonctions HTTP avec des méthodes et un niveau d’autorisation :

app.HTTP("myApi", myHandler,
    sdk.WithMethods("GET", "POST"),
    sdk.WithAuth("anonymous"),
)

Diffusion en continu HTTP

Go Worker prend en charge le streaming HTTP pour les scénarios tels que les événements envoyés par le serveur ou l’envoi de données de réponse volumineuses :

func streamHandler(w http.ResponseWriter, r *http.Request) {
    flusher, ok := w.(http.Flusher)
    if !ok {
        http.Error(w, "streaming not supported", http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type", "text/event-stream")
    for i := 0; i < 10; i++ {
        fmt.Fprintf(w, "data: message %d\n\n", i)
        flusher.Flush()
    }
}

Déclencheur de minuteur

Les déclencheurs de minuteur s’exécutent selon une planification définie par une expression cron :

app.Timer("myScheduledFunc", timerHandler,
    sdk.WithSchedule("0 */5 * * * *"),
)

func timerHandler(ctx context.Context, timer bindings.TimerInfo) error {
    log.Printf("Timer trigger executed at: %s", timer.ScheduleStatus.Next)
    return nil
}

Durable Functions

Go prend en charge les orchestrations et activités Durable Functions via le middleware/durabletask package. Inscrivez vos orchestrateurs et activités avec le middleware Durable avant d’ajouter le middleware à l’application de fonction :

durable := durabletask.Middleware()
durable.Orchestrator("HelloCities", helloCities)
durable.Activity("SayHello", sayHello)
app.Use(durable)

Durable Functions for Go nécessite l’extension Durable Task version 3.15.0 ou ultérieure. Les entités ne sont pas actuellement prises en charge. Pour une application complète, voir l’exemple Durable Functions.

Gestion des dépendances

Les projets de code Go utilisent des modules Go standard pour la gestion des dépendances.

Initialiser un nouveau module :
```
go mod init myapp
```
Ajoutez le kit de développement logiciel (SDK) du worker Go pour Azure Functions :
```
go get github.com/azure/azure-functions-golang-worker
```
Pour la prise en charge du déclencheur Blob, la dépendance est incluse automatiquement via l’import vide de triggers/blob.
Nettoyer les dépendances :
```
go mod tidy
```

Exécuter en local

Utilisez Azure Functions Core Tools pour exécuter votre projet localement :

func start

Outils de base automatiquement :

Détecte FUNCTIONS_WORKER_RUNTIME = "native" à partir de local.settings.json.
Résout le runtime du worker natif en Go lorsqu’un fichier go.mod est présent.
S’exécute go build -o bin/app . pour compiler votre projet pour votre système d’exploitation local.
Démarre l’hôte Azure Functions, qui communique avec le binaire compilé sur gRPC.
Affiche vos points de terminaison de fonction (par exemple, http://localhost:7071/api/hello).

Permet local.settings.json de configurer des variables d’environnement pour le développement local :

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "",
        "FUNCTIONS_WORKER_RUNTIME": "native"
    }
}

La valeur générée AzureWebJobsStorage est vide pour les projets Go. Définissez-la sur une chaîne de connexion à un compte de stockage ou UseDevelopmentStorage=true lorsque vous utilisez des déclencheurs qui nécessitent un stockage de l’hôte pendant le développement local.

Deployment

Compilation et empaquetage

Azure Functions version Core Tools 4.12 ou version ultérieure gère les builds Go pour les flux de déploiement locaux et Azure courants :

func start génère votre projet en tant que bin/application pour votre système d’exploitation local avant de démarrer l’hôte Functions local.
func azure functionapp publish génère, empaquette et déploie votre projet dans une application de fonctions existante dans Azure.
func pack génère votre projet en tant que bin/app pour Linux x64 et crée un package .zip déployable.

Lors de l’empaquetage de Azure, le fichier .zip généré contient les fichiers nécessaires à l’hôte Linux Functions. Le fichier binaire compilé est stocké en tant que fichier bin/application dans votre projet local, mais Core Tools le place à la racine du package de déploiement en tant qu’application.

Si vous utilisez func pack --no-build, vous devez générer le binaire Linux x64 avant d’empaqueter :

CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o bin/app .

Déployer avec Core Tools

Utilisez func azure functionapp publish pour déployer votre projet Go sur une application de fonction existante dans Azure :

func azure functionapp publish <APP_NAME>

Remplacez <APP_NAME> par le nom de votre application de fonction.

Déployer un package zip

Utilisez func pack quand vous devez créer un package de déploiement séparément de la publication :

Créez un artefact zip déployable :
```
func pack
```

Déployez le package à l’aide de la Azure CLI :

az functionapp deployment source config-zip --resource-group <RESOURCE_GROUP> --name <APP_NAME> --src <ZIP_FILE_PATH>

Le package produit par func pack est prêt à s'exécuter dans Azure. Ne demandez donc pas de build distante lorsque vous le déployez.

Prise en charge de Docker

Vous pouvez exécuter des projets de code Go dans des conteneurs. Initialisez un projet avec la prise en charge de Docker :

func init --worker-runtime go --docker

La commande génère un Dockerfile ainsi que les fichiers de projet standard.

Télémétrie et observabilité

Le Worker Go d’Azure Functions prend en charge la journalisation structurée et l’observabilité basée sur OpenTelemetry. Utilisez des méthodes prenant en compte le contexte du package standard log/slog, telles que slog.InfoContext, pour mettre en corrélation les journaux avec l’appel de fonction actuel. Pour activer OpenTelemetry, configurez l’hôte Functions et inscrivez l’intergiciel Go Worker OpenTelemetry dans votre application. Pour obtenir des instructions de configuration, consultez Use OpenTelemetry avec Azure Functions.

Limitations connues

func new n’est pas pris en charge. Ajoutez des fonctions en modifiant main.go directement.
Les applications de fonction Go tournent uniquement sous Linux dans le plan Consommation flexible.
Seuls les déclencheurs dédiés listés dans Triggers et les déclencheurs d’hôte génériques compatibles sont pris en charge.
Les liaisons d’entrée supplémentaires et celles de sortie non-HTTP ne sont actuellement pas prises en charge.
La création de packages Go dans Core Tools cible actuellement les applications pour Linux x64.

Étapes suivantes

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-10-23