Uitbreidingsmogelijkheden toevoegen

Mogelijkheden definiëren wat een Azure Developer CLI-extensie (azd) kan doen, van het toevoegen van aangepaste opdrachten aan het koppelen aan de levenscyclus van de implementatie. In dit artikel wordt uitgelegd hoe u functionaliteit toevoegt aan de Contoso Resource Tagger-voorbeeldextensie uit de quickstart Een voorbeeldextensie bouwen. U kunt dezelfde patronen toepassen op elke extensie.

Voor elke mogelijkheid zijn twee dingen vereist: een vermelding in de capabilities matrix van uw extensiemanifest en de bijbehorende implementatie in uw extensiecode.

Opmerking

azd extensies zijn momenteel beschikbaar in de bètaversie.

Beschikbare mogelijkheden

azd extensies kunnen de volgende mogelijkheden declareren:

custom-commands: Voegt nieuwe opdrachten en opdrachtgroepen toe aan azd onder de naamruimte van uw extensie. De voorbeeldextensie voegt bijvoorbeeld toe azd tagger show. Gebruik deze functionaliteit om taken beschikbaar te maken die gebruikers rechtstreeks via de opdrachtregel uitvoeren.
lifecycle-events: Abonneert zich op gebeurtenissen die azd activeert tijdens het uitvoeren, zoals preprovision, postprovision of postdeploy. Uw extensie voert aangepaste logica uit op die punten zonder de gebruiker die deze rechtstreeks aanroept. De voorbeeldextensie controleert bijvoorbeeld op vereiste tags op preprovision voordat resources worden aangemaakt.
service-target-provider: Registreert een nieuw implementatiedoel, zodat azd u weet hoe u een service inpakt en implementeert op een host die niet standaard wordt ondersteund. Een servicedoelstelling komt overeen met de waarde host in azure.yaml. U kunt bijvoorbeeld een provider toevoegen die een service implementeert op een platform van derden of een interne hostingomgeving.
framework-service-provider: Registreert ondersteuning voor een taal of framework, dus azd weet hoe dat projecttype moet worden hersteld, gebouwd en verpakt. Dit komt overeen met de language-waarde in azure.yaml. U kunt bijvoorbeeld buildondersteuning toevoegen voor een taal die azd niet standaard wordt herkend.
provisioning-provider: Vervangt hoe azd infrastructuur inricht tijdens azd provision en azd up. In plaats van de ingebouwde Bicep- of Terraform-stroom definieert uw extensie wat er gebeurt. U kunt bijvoorbeeld een ander hulpprogramma voor infrastructuur als code of een aangepaste implementatie-API integreren.
validation-provider: Voegt controles toe aan de azd-validatiepijplijn die op een project of omgeving worden uitgevoerd. U kunt bijvoorbeeld controleren of naamconventies, vereiste tags of beveiligingsinstellingen zijn ingesteld voordat een implementatie wordt uitgevoerd.
mcp-server: maakt de functionaliteit van uw extensie beschikbaar als MCP-hulpprogramma's (Model Context Protocol) die AI-agents, zoals GitHub Copilot, kunnen detecteren en aanroepen. De voorbeeldextensie kan bijvoorbeeld een suggest_tags hulpprogramma beschikbaar maken. Zie Een MCP-server toevoegen aan een extensie voor meer informatie.
metadata: biedt uitgebreidere metagegevens voor opdrachten en configuratie die azd worden gebruikt om uw extensie te beschrijven, zoals gedetailleerde opdrachtbeschrijvingen en configuratiehints die worden weergegeven in help-uitvoer en IntelliSense.

Dit artikel is gericht op de twee meest voorkomende mogelijkheden: aangepaste opdrachten en levenscyclus-gebeurtenissen. Zie mcp-server voor de mogelijkheid. Zie de naslaginformatie over het extensieframework voor meer informatie over de mogelijkheden van de provider.

Aangepaste opdrachten toevoegen

Met de custom-commands mogelijkheid kan uw extensie nieuwe opdrachten registreren onder een naamruimte in azd. De voorbeeldextensie maakt al gebruik van deze mogelijkheid voor de azd tagger show opdracht.

Declareer de mogelijkheid in extension.yaml.
```
capabilities:
  - custom-commands
```
Bouw uw opdrachten met behulp van de azdext.NewExtensionRootCommand helper, waarmee de standaardvlagmen azd en omgevingsvariabelen worden geregistreerd, zodat u ze niet handmatig hoeft te declareren:
```
import "github.com/azure/azure-dev/cli/azd/pkg/azdext"

func NewRootCommand() *cobra.Command {
    rootCmd, extCtx := azdext.NewExtensionRootCommand(azdext.ExtensionCommandOptions{
        Name:  "tagger",
        Use:   "tagger <command> [options]",
        Short: "Standardize and report Azure resource tags.",
    })

    rootCmd.AddCommand(newShowCommand(extCtx))
    // Add other subcommands here.
    return rootCmd
}
```
De helper retourneert een *ExtensionContext waarmee de opgeloste waarden van de standaardvlagmen worden weergegeven, zoals Environment en OutputFormat. Geef de context door aan je subopdrachten en lees deze uit in hun RunE-handlers, in plaats van de standaardflags opnieuw te declareren.

Met de lifecycle-events mogelijkheid kan uw extensie aangepaste logica uitvoeren tijdens project- en servicelevenscyclus-gebeurtenissen, zoals preprovision of postdeploy. Gebruik voor de voorbeeldextensie een preprovision gebeurtenis om te controleren of de vereiste tags zijn ingesteld voordat azd resources worden ingericht.

Declareer de mogelijkheid in extension.yaml.

capabilities:
  - custom-commands
  - lifecycle-events

Voeg een listen opdracht toe aan uw extensie. azd roept deze opdracht aan om de bidirectionele verbinding tot stand te brengen die wordt gebruikt voor gebeurtenissen. Gebruik de azdext.NewExtensionHost builder om uw eventhandlers te registreren:

func newListenCommand() *cobra.Command {
    return &cobra.Command{
        Use:    "listen",
        Short:  "Starts the extension and listens for azd events.",
        Hidden: true,
        RunE: func(cmd *cobra.Command, args []string) error {
            ctx := azdext.WithAccessToken(cmd.Context())

            azdClient, err := azdext.NewAzdClient()
            if err != nil {
                return fmt.Errorf("failed to create azd client: %w", err)
            }
            defer azdClient.Close()

            host := azdext.NewExtensionHost(azdClient).
                WithProjectEventHandler(
                    "preprovision",
                    func(ctx context.Context, args *azdext.ProjectEventArgs) error {
                        fmt.Printf("Verifying required tags for project: %s\n", args.Project.Name)
                        // Add your tag validation logic here.
                        return nil
                    },
                )

            // Run blocks until azd closes the connection.
            if err := host.Run(ctx); err != nil {
                return fmt.Errorf("failed to run extension: %w", err)
            }

            return nil
        },
    }
}

Registreer de opdracht listen op je hoofdopdracht:
```
rootCmd.AddCommand(newListenCommand())
```

Wanneer een gebruiker azd provision of azd up uitvoert, roept azd uw extensie aan en roept het de handler preprovision aan voordat resources worden ingericht.

Service-gebeurtenissen filteren

Service-gebeurtenis-handlers ondersteunen optionele filtering, zodat u alleen specifieke servicetypen kunt verwerken. U kunt bijvoorbeeld de gebeurtenis prepackage alleen afhandelen voor Python-container-app-services:

host := azdext.NewExtensionHost(azdClient).
    WithServiceEventHandler(
        "prepackage",
        func(ctx context.Context, args *azdext.ServiceEventArgs) error {
            fmt.Printf("Packaging service: %s\n", args.Service.Name)
            return nil
        },
        &azdext.ServiceEventOptions{
            Host:     "containerapp",
            Language: "python",
        },
    )

Opnieuw bouwen en testen

Nadat u een mogelijkheid hebt toegevoegd, bouwt u de extensie opnieuw en test u het nieuwe gedrag:

Als u de watcher gebruikt, worden uw wijzigingen automatisch opnieuw opgebouwd. Anders bouwt u handmatig:
```
azd x build
```
Test de mogelijkheid. Voer voor levenscyclus-gebeurtenissen een opdracht uit waarmee de gebeurtenis wordt geactiveerd, zoals azd provision.

Feedback

Is deze pagina nuttig?

Last updated on 2026-07-29