Tutoriel : Créer et publier un produit

Dans ce tutoriel, vous allez apprendre à :

Prérequis

• Apprenez la terminologie relative à Gestion des API Azure.
• Suivez le guide de démarrage rapide suivant : Créer une instance du service Gestion des API Azure.
• Effectuez également toutes les étapes du tutoriel suivant : Importer et publier votre première API.

Créer et publier un produit

az apim product create --resource-group apim-hello-word-resource-group \
    --product-name "Contoso product" --product-id contoso-product \
    --service-name apim-hello-world --subscription-required true \
    --state published --description "This is a test."

az apim product list --resource-group apim-hello-word-resource-group \
    --service-name apim-hello-world --output table

az apim product delete --product-id contoso-product \
    --resource-group apim-hello-word-resource-group \
    --service-name apim-hello-world --delete-subscriptions true

Ajouter des configurations

Poursuivez la configuration du produit après l’avoir enregistré. Dans votre instance Gestion des API, sélectionnez le produit dans la fenêtre Produits. Ajouter ou mettre à jour :

Ajout d’API à un produit

Les produits sont des associations d’une ou de plusieurs API. Vous pouvez inclure de nombreuses API et les proposer aux développeurs dans le portail des développeurs. Lors de la création du produit, vous pouvez ajouter une ou plusieurs API existantes. Vous pouvez aussi ajouter des API au produit ultérieurement, à partir de la page Paramètres des produits ou lors de la création d’une API.

Ajouter une API à un produit existant

az apim product api delete --resource-group apim-hello-word-resource-group \
    --api-id petstore-api --product-id contoso-product \
    --service-name apim-hello-world

Accès aux API du produit

Une fois que vous avez publié un produit, les développeurs peuvent accéder aux API. Selon la configuration du produit, ils devront peut-être s’abonner au produit pour y accéder.

• Produit protégé : Les développeurs doivent d’abord s’abonner à un produit protégé pour avoir accès aux API de ce produit. Quand ils s’abonnent, ils obtiennent une clé d’abonnement qui leur permet d’accéder à toutes les API de ce produit. Si vous avez créé l’instance Gestion des API, vous êtes abonné à chaque produit par défaut, car vous êtes déjà administrateur. Pour plus d’informations, consultez Abonnements dans Gestion des API Azure.

  Lorsqu’un client effectue une demande d’API avec une clé d’abonnement de produit valide, Gestion des API traite la demande et autorise l’accès dans le contexte du produit. Les stratégies et les règles de contrôle d’accès configurées pour le produit peuvent être appliquées.

  Conseil

  Vous pouvez créer ou mettre à jour l’abonnement de l’utilisateur à un produit avec des clés d’abonnement personnalisées via une API REST ou une commande PowerShell.

• Produit ouvert : Les développeurs peuvent accéder aux API d’un produit ouvert sans clé d’abonnement. Toutefois, vous pouvez configurer d’autres mécanismes pour sécuriser l’accès client aux API, notamment OAuth 2.0, des certificats clients et la restriction des adresses IP des appelants.

  Notes

  Les produits ouverts ne sont pas listés dans le portail des développeurs. Les développeurs ne peuvent donc pas s’informer sur ces produits, ni s’y abonner. Ils ne sont visibles que par le groupe Administrateurs. Vous devez utiliser un autre mécanisme pour informer les développeurs sur les API accessibles sans clé d’abonnement.

  Lorsqu’un client effectue une demande d’API sans clé d’abonnement :

  • Gestion des API vérifie si l’API est associée à un produit ouvert. Une API peut être associée au maximum à un produit ouvert.

  • Si le produit ouvert existe, il traite ensuite la demande dans le contexte de ce produit ouvert. Les stratégies et les règles de contrôle d’accès configurées pour le produit ouvert peuvent être appliquées.

Pour plus d’informations, consultez Traitement des requêtes par Gestion des API avec ou sans clé d’abonnement.

Étapes suivantes

Dans ce didacticiel, vous avez appris à :

Passez au tutoriel suivant :

Dans cet article, vous utilisez Terraform pour créer une instance Gestion des API Azure, une API, un produit, un groupe et des associations entre le produit et l’API, ainsi que le produit et le groupe.

Terraform permet la définition, l’aperçu et le déploiement d’une infrastructure cloud. Terraform vous permet de créer des fichiers de configuration à l’aide de la syntaxe HCL. La syntaxe HCL vous permet de spécifier un fournisseur de services cloud, tel qu’Azure, et les éléments qui composent votre infrastructure cloud. Après avoir créé vos fichiers de configuration, vous créez un plan d’exécution qui vous permet d’afficher un aperçu de vos modifications d’infrastructure avant leur déploiement. Une fois que vous avez vérifié les modifications, vous appliquez le plan d’exécution pour déployer l’infrastructure.

Prérequis

• Créer un compte Azure avec un abonnement actif. Vous pouvez créer un compte gratuitement.

• Installez et configurez Terraform.

Implémenter le code Terraform

1. Créez un répertoire dans lequel tester et exécuter l’exemple de code Terraform et définissez-le en tant que répertoire actif.

2. Créez un fichier nommé main.tf et insérez le code suivant :

   resource "random_pet" "rg_name" {
     prefix = var.resource_group_name_prefix
   }
   
   resource "azurerm_resource_group" "rg" {
     location = var.resource_group_location
     name     = random_pet.rg_name.id
   }
   
   resource "random_string" "apim_service_name" {
     length  = 8
     lower   = true
     numeric = false
     special = false
     upper   = false
   }
   
   resource "azurerm_api_management" "apim_service" {
     name                = "${random_string.apim_service_name.result}-apim-service"
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
     publisher_name      = "Example Publisher"
     publisher_email     = "publisher@example.com"
     sku_name            = "Developer_1"
     tags = {
       Environment = "Example"
     }
     policy {
       xml_content = <<XML
       <policies>
         <inbound />
         <backend />
         <outbound />
         <on-error />
       </policies>
   XML
     }
   }
   
   resource "random_string" "api_name" {
     length  = 8
     lower   = true
     numeric = false
     special = false
     upper   = false
   }
   
   resource "random_string" "content_value" {
     length  = 8
     lower   = true
     numeric = false
     special = false
     upper   = false
   }
   
   resource "azurerm_api_management_api" "api" {
     name                = "${random_string.api_name.result}-api"
     resource_group_name = azurerm_resource_group.rg.name
     api_management_name = azurerm_api_management.apim_service.name
     revision            = "1"
     display_name        = "${random_string.api_name.result}-api"
     path                = "example"
     protocols           = ["https", "http"]
     description         = "An example API"
     import {
       content_format = var.open_api_spec_content_format
       content_value  = var.open_api_spec_content_value
     }
   }
   
   resource "random_string" "product_name" {
     length  = 8
     lower   = true
     numeric = false
     special = false
     upper   = false
   }
   
   resource "azurerm_api_management_product" "product" {
     product_id            = "${random_string.product_name.result}-product"
     resource_group_name   = azurerm_resource_group.rg.name
     api_management_name   = azurerm_api_management.apim_service.name
     display_name          = "${random_string.product_name.result}-product"
     subscription_required = true
     approval_required     = false
     published             = true
     description           = "An example Product"
   }
   
   resource "random_string" "group_name" {
     length  = 8
     lower   = true
     numeric = false
     special = false
     upper   = false
   }
   
   resource "azurerm_api_management_group" "group" {
     name                = "${random_string.group_name.result}-group"
     resource_group_name = azurerm_resource_group.rg.name
     api_management_name = azurerm_api_management.apim_service.name
     display_name        = "${random_string.group_name.result}-group"
     description         = "An example group"
   }
   
   resource "azurerm_api_management_product_api" "product_api" {
     resource_group_name = azurerm_resource_group.rg.name
     api_management_name = azurerm_api_management.apim_service.name
     product_id          = azurerm_api_management_product.product.product_id
     api_name            = azurerm_api_management_api.api.name
   }
   
   resource "azurerm_api_management_product_group" "product_group" {
     resource_group_name = azurerm_resource_group.rg.name
     api_management_name = azurerm_api_management.apim_service.name
     product_id          = azurerm_api_management_product.product.product_id
     group_name          = azurerm_api_management_group.group.name
   }
   

3. Créez un fichier nommé outputs.tf et insérez le code suivant :

   output "resource_group_name" {
     value = azurerm_resource_group.rg.name
   }
   
   output "apim_service_name" {
     value = azurerm_api_management.apim_service.name
   }
   
   output "api_name" {
     value = azurerm_api_management_api.api.name
   }
   
   output "product_name" {
     value = azurerm_api_management_product.product.product_id
   }
   
   output "group_name" {
     value = azurerm_api_management_group.group.name
   }
   
   output "service_id" {
     description = "The ID of the API Management Service created"
     value       = azurerm_api_management.apim_service.id
   }
   
   output "gateway_url" {
     description = "The URL of the Gateway for the API Management Service"
     value       = azurerm_api_management.apim_service.gateway_url
   }
   
   output "service_public_ip_addresses" {
     description = "The Public IP addresses of the API Management Service"
     value       = azurerm_api_management.apim_service.public_ip_addresses
   }
   
   output "api_outputs" {
     description = "The IDs, state, and version outputs of the APIs created"
     value = {
       id             = azurerm_api_management_api.api.id
       is_current     = azurerm_api_management_api.api.is_current
       is_online      = azurerm_api_management_api.api.is_online
       version        = azurerm_api_management_api.api.version
       version_set_id = azurerm_api_management_api.api.version_set_id
     }
   }
   
   output "product_id" {
     description = "The ID of the Product created"
     value       = azurerm_api_management_product.product.id
   }
   
   output "product_api_id" {
     description = "The ID of the Product/API association created"
     value       = azurerm_api_management_product_api.product_api.id
   }
   
   output "product_group_id" {
     description = "The ID of the Product/Group association created"
     value       = azurerm_api_management_product_group.product_group.id
   }
   

4. Créez un fichier nommé providers.tf et insérez le code suivant :

   terraform {
     required_version = ">=1.0"
     
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~>3.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~>3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

5. Créez un fichier nommé variables.tf et insérez le code suivant :

   variable "resource_group_name_prefix" {
     type        = string
     default     = "rg"
     description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
   }
   
   variable "resource_group_location" {
     type        = string
     default     = "eastus"
     description = "Location of the resource group."
   }
   
   variable "open_api_spec_content_format" {
     type        = string
     default     = "swagger-link-json"
     description = "The format of the content from which the API Definition should be imported. Possible values are: openapi, openapi+json, openapi+json-link, openapi-link, swagger-json, swagger-link-json, wadl-link-json, wadl-xml, wsdl and wsdl-link."
     validation {
       condition     = contains(["openapi", "openapi+json", "openapi+json-link", "openapi-link", "swagger-json", "swagger-link-json", "wadl-link-json", "wadl-xml", "wsdl", "wsdl-link"], var.open_api_spec_content_format)
       error_message = "open_api_spec_content_format must be one of the following: openapi, openapi+json, openapi+json-link, openapi-link, swagger-json, swagger-link-json, wadl-link-json, wadl-xml, wsdl and wsdl-link."
     }
   }
   
   variable "open_api_spec_content_value" {
     type        = string
     default     = "https://petstore3.swagger.io/api/v3/openapi.json"
     description = "The Content from which the API Definition should be imported. When a content_format of *-link-* is specified this must be a URL, otherwise this must be defined inline."
   }
   

Initialiser Terraform

Exécutez terraform init pour initialiser le déploiement Terraform. Cette commande télécharge le fournisseur Azure à utiliser pour la gestion de vos ressources Azure.

terraform init -upgrade

Points essentiels :

• Le paramètre -upgrade met à niveau les plug-ins de fournisseur nécessaires vers la version la plus récente qui est conforme aux contraintes de version de la configuration.

Créer un plan d’exécution Terraform

Exécutez terraform plan pour créer un plan d’exécution.

terraform plan -out main.tfplan

Points essentiels :

• La commande terraform plan crée un plan d’exécution, mais ne l’exécute pas. Au lieu de cela, elle détermine les actions nécessaires pour créer la configuration spécifiée dans vos fichiers de configuration. Ce modèle vous permet de vérifier si le plan d’exécution répond à vos attentes avant d’apporter des modifications aux ressources réelles.
• Le paramètre facultatif -out vous permet de spécifier un fichier de sortie pour le plan. L’utilisation du paramètre -out garantit que le plan que vous avez examiné correspond exactement à ce qui est appliqué.

Appliquer un plan d’exécution Terraform

Exécutez terraform apply pour appliquer le plan d’exécution à votre infrastructure cloud.

terraform apply main.tfplan

Points essentiels :

• La commande exemple terraform apply part du principe que vous avez préalablement exécuté terraform plan -out main.tfplan.
• Si vous avez spécifié un autre nom de fichier pour le paramètre -out, utilisez ce même nom dans l’appel à terraform apply.
• Si vous n’avez pas utilisé le paramètre -out, appelez terraform apply sans aucun paramètre.

Vérifier les résultats

Exécutez az apim show pour afficher la Gestion des API Azure :

az apim show --<apim_service_name> --<resource_group_name>

Nettoyer les ressources

Quand vous n’avez plus besoin des ressources créées par le biais de Terraform, effectuez les étapes suivantes :

1. Exécutez le plan Terraform et spécifiez l’indicateur destroy.

   terraform plan -destroy -out main.destroy.tfplan
   

   Points essentiels :

   • La commande terraform plan crée un plan d’exécution, mais ne l’exécute pas. Au lieu de cela, elle détermine les actions nécessaires pour créer la configuration spécifiée dans vos fichiers de configuration. Ce modèle vous permet de vérifier si le plan d’exécution répond à vos attentes avant d’apporter des modifications aux ressources réelles.
   • Le paramètre facultatif -out vous permet de spécifier un fichier de sortie pour le plan. L’utilisation du paramètre -out garantit que le plan que vous avez examiné correspond exactement à ce qui est appliqué.

2. Exécutez terraform apply pour appliquer le plan d’exécution.

   terraform apply main.destroy.tfplan
   

Résoudre les problèmes liés à Terraform sur Azure

Résoudre les problèmes courants liés à l’utilisation de Terraform sur Azure.

Étapes suivantes