Partager via

Tutoriel : Créer et publier un produit

  • Article

S’APPLIQUE À : Tous les niveaux de Gestion des API

Dans Gestion des API Azure, un produit contient une ou plusieurs API, un quota et des conditions d’utilisation. Une fois le produit publié, les développeurs peuvent s’y abonner et commencer à utiliser ses API.

Dans ce tutoriel, vous allez apprendre à :

  • Créer et publier un produit
  • Ajouter une API au produit
  • Accéder aux API du produit

Produits de Gestion des API dans le portail

Prérequis

Créer et publier un produit

  1. Connectez-vous au portail Azure et accédez à votre instance de Gestion des API.

  2. Dans le volet de navigation gauche, sélectionnez Produits>+ Ajouter.

    Ajouter un produit dans le Portail Azure

  3. Dans la fenêtre Ajouter un produit, entrez les valeurs décrites dans le tableau suivant pour créer votre produit.

    Ajouter une fenêtre de produit

    Nom Description
    Nom complet Le nom qui doit apparaître dans le portail des développeurs.
    Description Spécifiez des informations sur le produit, comme son objectif, les API auxquelles il donne accès ainsi que d’autres informations détaillées.
    État Sélectionnez Publié si vous voulez publier le produit sur le portail des développeurs. Avant que les développeurs puissent découvrir les API d’un produit, ce produit doit être publié. Par défaut, les nouveaux produits ne sont pas publiés.
    Nécessite un abonnement Sélectionnez si un utilisateur doit s’abonner pour utiliser le produit (le produit est protégé) et si une clé d’abonnement doit être utilisée pour accéder aux API du produit. Si un abonnement n’est pas obligatoire (le produit est ouvert), une clé d’abonnement n’est pas nécessaire pour accéder aux API du produit. Voir Accès aux API du produit plus loin dans cet article.
    Nécessite une approbation Sélectionnez cette option si vous voulez qu’un administrateur révise et accepte ou refuse les tentatives d’abonnement à ce produit. Si cette option n’est pas sélectionnée, les tentatives d’abonnement sont automatiquement approuvées.
    Limite du nombre d’abonnements Si vous le souhaitez, limitez le nombre d’abonnements simultanés.
    Conditions légales Vous pouvez inclure les conditions d’utilisation que les abonnés doivent accepter pour pouvoir utiliser le produit.
    API Sélectionnez une ou plusieurs API. Vous pouvez aussi ajouter des API après avoir créé le produit. Pour plus d’informations, consultez Ajouter des API à un produit plus loin dans cet article.

    Si le produit est ouvert (ne nécessite pas d’abonnement), vous pouvez uniquement ajouter une API qui n’est pas associée à un autre produit ouvert.

  4. Sélectionnez Créer pour créer votre produit.

Attention

Faites attention lors de la configuration d’un produit qui ne nécessite pas d’abonnement. Cette configuration peut être trop permissive et rendre les API du produit plus vulnérables à certaines menaces de sécurité des API.

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 :

Élément Description
Paramètres Métadonnées et état du produit
API API associées au produit
Stratégies Stratégies appliquées aux API du produit
Contrôle d’accès Visibilité du produit pour les développeurs ou les invités
Abonnements Abonnés au produit

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

  1. Dans le volet de navigation gauche de votre instance du service Gestion des API, sélectionnez Produits.
  2. Sélectionnez un produit, puis sélectionnez API.
  3. Sélectionnez + Ajouter API.
  4. Sélectionnez une ou plusieurs API, puis Sélectionner.

Ajouter une API à un produit existant

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 à :

  • Créer et publier un produit
  • Ajouter une API au produit
  • Accéder aux API du produit

Passez au tutoriel suivant :

Créer une API vide et simuler des réponses de l’API

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.

  • Spécifiez la version requise de Terraform et les fournisseurs requis.
  • Définissez des variables pour le préfixe du nom du groupe de ressources, l’emplacement du groupe de ressources, ainsi que le format et la valeur du contenu pour l'importation de la définition de l'API.
  • Créez un groupe de ressources avec un nom aléatoire.
  • Créez un service Gestion des API avec un nom aléatoire.
  • Créez une API avec un nom aléatoire.
  • Créez un produit avec un nom aléatoire dans le service Gestion des API.
  • Créez un groupe avec un nom aléatoire.
  • Associez l’API au produit.
  • Associez le groupe au produit.
  • Affichez les valeurs aléatoires telles que les noms du groupe de ressources, du service Gestion des API, de l’API, du produit et du groupe.

Prérequis

Implémenter le code Terraform

Notes

L’exemple de code de cet article se trouve dans le dépôt GitHub Azure Terraform. Vous pouvez afficher le fichier journal contenant les résultats des tests des versions actuelles et précédentes de Terraform.

Consultez d’autres articles et exemples de code montrant comment utiliser Terraform pour gérer des ressources Azure.

  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

Créer une API vide et simuler des réponses de l’API.