Compartilhar via

Tutorial: Criar e publicar um produto

  • Artigo

APLICA-SE A: todas as camadas do Gerenciamento de API

No Gerenciamento de API do Azure, um produto contém uma ou mais APIs, uma cota de uso e os termos de uso. Uma vez publicado o produto, os desenvolvedores podem assinar o produto e começar a usar as APIs dele.

Neste tutorial, você aprende a:

  • Criar e publicar um produto
  • Adicionar uma API ao produto
  • Acessar APIs do produto

Produtos do Gerenciamento de API no portal

Pré-requisitos

Criar e publicar um produto

  1. Entre no portal do Azure e navegue até sua instância do Gerenciamento de API.

  2. No painel de navegação esquerdo, selecione Produtos>+ Adicionar.

    Adicionar produto no portal do Azure

  3. Na janela Adicionar produto, insira os valores descritos na tabela a seguir para criar seu produto.

    Adicionar janela do produto

    Nome Descrição
    Nome de exibição O nome que você deseja que seja mostrado no portal do desenvolvedor.
    Descrição Forneça informações sobre o produto, como sua finalidade, as APIs a que ele fornece acesso, entre outros detalhes.
    Estado Selecione Publicado se você quiser publicar o produto no portal do desenvolvedor. Antes que as APIs em um produto possam ser descobertas pelos desenvolvedores, o produto deve ser publicado. Por padrão, novos produtos não são publicados.
    Exige assinatura Selecione se um usuário precisa assinar para usar o produto (o produto está protegido) e uma chave de assinatura precisa ser usada para acessar as APIs do produto. Se uma assinatura não for necessária (se o produto estiver aberto), uma chave de assinatura não será necessária para acessar as APIs do produto. Confira Acesso a APIs de produto mais adiante neste artigo.
    Requer aprovação Selecione se desejar que um administrador analise e aceite ou rejeite as tentativas de assinatura para o produto. Se não for selecionado, as tentativas de assinatura serão aprovadas automaticamente.
    Limite de contagem de assinaturas Opcionalmente, limite a contagem de várias assinaturas simultâneas.
    Termos legais Você pode incluir os termos de uso para o produto que os assinantes devem aceitar a fim de usá-lo.
    APIs Selecione uma ou mais APIs. Você também pode adicionar APIs após criar o produto. Para obter mais informações, confira Adicionar APIs a um produto mais adiante neste artigo.

    Se o produto estiver aberto (não exigir uma assinatura), você só poderá adicionar uma API que não estiver associada a outro produto aberto.

  4. Selecione Criar para criar o novo produto.

Cuidado

Tenha cuidado ao configurar um produto que não exija uma assinatura. Essa configuração pode ser excessivamente permissiva e deixar as APIs do produto mais vulneráveis a determinadas ameaças à segurança da API.

Adicionar mais configurações

Continue configurando o produto depois de salvá-lo. Na instância do Gerenciamento de API, selecione o produto na janela Produtos. Adicione ou atualize:

Item Descrição
Configurações Metadados e estado do produto
APIs APIs associadas ao produto
Políticas Políticas aplicadas às APIs do produto
Controle de acesso Visibilidade do produto para desenvolvedores ou convidados
Assinaturas Assinantes do produto

Adicionar APIs a um produto

Os produtos são associações de uma ou mais APIs. Você pode incluir muitas APIs e oferecê-las aos desenvolvedores no portal do desenvolvedor. Durante a criação do produto, você pode adicionar uma ou mais APIs existentes. Você também pode adicionar uma API ao produto mais tarde, seja na página Configurações do produto ou durante a criação de uma API.

Adicionar uma API a um produto existente

  1. No painel de navegação esquerdo da sua instância do Gerenciamento de API, selecione Produtos.
  2. Selecione um produto e escolha APIs.
  3. Selecione + Adicionar API.
  4. Selecione uma ou mais APIs e escolha Selecionar.

Adicionar uma API a um produto existente

Acesso a APIs de produto

Depois de publicar um produto, os desenvolvedores podem acessar as APIs. Dependendo de como o produto está configurado, talvez seja necessário assinar o produto para obter acesso.

  • Produto protegido – os desenvolvedores devem primeiro assinar um produto protegido para obter acesso às APIs do produto. Quando eles assinam, recebem uma chave de assinatura que pode acessar qualquer API nesse produto. Se você criou a instância do Gerenciamento de API, você já é um administrador, portanto, está inscrito em cada produto, por padrão. Para obter mais informações, confira Assinaturas no Gerenciamento de API do Azure.

    Quando um cliente faz uma solicitação de API com uma chave de assinatura de produto válida, o Gerenciamento de API processa a solicitação e permite o acesso no contexto do produto. As políticas e as regras de controle de acesso configuradas para o produto podem ser aplicadas.

    Dica

    Você pode criar ou atualizar a assinatura de um usuário para um produto com chaves de assinatura personalizadas por meio de uma API REST ou de um comando do PowerShell.

  • Produto aberto – os desenvolvedores podem acessar as APIs de um produto aberto sem uma chave de assinatura. No entanto, você pode configurar outros mecanismos para proteger o acesso de cliente às APIs, incluindo OAuth 2.0, certificados do cliente e restrição de endereços IP do chamador.

    Observação

    Os produtos abertos não estão listados no portal do desenvolvedor para que os desenvolvedores aprendam mais sobre ele ou os assinem. Elas só são visíveis para o grupo Administradores. Você precisará usar outro mecanismo para informar os desenvolvedores sobre as APIs que podem ser acessadas sem uma chave de assinatura.

    Quando um cliente faz uma solicitação de API sem uma chave de assinatura:

    • O Gerenciamento de API verifica se a API está associada a um produto aberto. Uma API pode ser associada a, no máximo, um produto aberto.

    • Se o produto aberto existir, ele processará a solicitação no contexto desse produto aberto. As políticas e as regras de controle de acesso configuradas para o produto aberto podem ser aplicadas.

Para obter mais informações, confira Como o Gerenciamento de API lida com solicitações com ou sem chaves de assinatura.

Próximas etapas

Neste tutorial, você aprendeu a:

  • Criar e publicar um produto
  • Adicionar uma API ao produto
  • Acessar APIs do produto

Prosseguir para o próximo tutorial:

Criar API em branco e simular respostas de API

Neste artigo, você usará o Terraform para criar uma instância de Gerenciamento de API do Azure, uma API, um produto, um grupo e associações entre o produto e a API e o produto e o grupo.

O Terraform permite a definição, a visualização e a implantação da infraestrutura de nuvem. Usando o Terraform, você cria arquivos de configuração usando sintaxe de HCL. A sintaxe da HCL permite que você especifique o provedor de nuvem, como o Azure, e os elementos que compõem sua infraestrutura de nuvem. Depois de criar os arquivos de configuração, você cria um plano de execução que permite visualizar as alterações de infraestrutura antes de serem implantadas. Depois de verificar as alterações, aplique o plano de execução para implantar a infraestrutura.

  • Especifique a versão necessária do Terraform e dos provedores necessários.
  • Defina variáveis para o prefixo do nome do grupo de recursos, o local do grupo de recursos e o formato e o valor do conteúdo para a importação de definição de API.
  • Crie um grupo de recursos com um nome aleatório.
  • Crie um serviço de Gerenciamento de API com um nome aleatório.
  • Crie uma API com um nome aleatório.
  • Crie um produto com um nome aleatório no serviço de Gerenciamento de API.
  • Crie um grupo com um nome aleatório.
  • Associe a API ao produto.
  • Associe o grupo ao produto.
  • Gera os valores aleatórios, como os nomes do grupo de recursos, serviço de Gerenciamento de API, API, produto e grupo.

Pré-requisitos

Implementar o código do Terraform

Observação

O código de exemplo deste artigo está localizado no repositório do GitHub do Azure Terraform. Você pode exibir o arquivo de log que contém os resultados do teste das versões atuais e anteriores do Terraform.

Veja mais artigos e exemplos de código mostrando como usar o Terraform para gerenciar recursos do Azure.

  1. Crie um diretório no qual testar e executar o código de exemplo do Terraform e faça dele o diretório atual.

  2. Crie um arquivo chamado main.tf, depois insira o código a seguir:

    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. Crie um arquivo chamado outputs.tf, depois insira o código a seguir:

    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. Crie um arquivo chamado providers.tf, depois insira o código a seguir:

    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. Crie um arquivo chamado variables.tf, depois insira o código a seguir:

    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."
}

Inicializar Terraform

Execute terraform init para inicializar a implantação do Terraform. Esse comando baixa o provedor do Azure necessário para gerenciar seus recursos do Azure.

terraform init -upgrade

Pontos principais:

  • O parâmetro -upgrade atualiza os plug-ins do provedor necessários para a versão mais recente que esteja em conformidade com as restrições de versão da configuração.

Criar um plano de execução Terraform

Execute o comando terraform plan para criar um plano de execução.

terraform plan -out main.tfplan

Pontos principais:

  • O comando terraform plan cria um plano de execução, mas não o executa. Em vez disso, ele determina quais ações são necessárias para criar a configuração especificada em seus arquivos de configuração. Esse padrão permite que você verifique se o plano de execução corresponde às suas expectativas antes de fazer qualquer alteração nos recursos reais.
  • O parâmetro opcional -out permite que você especifique um arquivo de saída para o plano. Usar o parâmetro -out garante que o plano que você examinou seja exatamente o que é aplicado.

Aplicar um plano de execução do Terraform

Execute terraform apply para aplicar o plano de execução à sua infraestrutura de nuvem.

terraform apply main.tfplan

Pontos principais:

  • O exemplo de comando do terraform apply pressupõe que você executou o terraform plan -out main.tfplan anteriormente.
  • Se você especificou um nome de arquivo diferente para o parâmetro -out, use esse mesmo nome de arquivo na chamada para terraform apply.
  • Se você não usou o parâmetro -out, chame terraform apply sem nenhum parâmetro.

Verifique os resultados

Execute az apim show para exibir o Gerenciamento de API do Azure:


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

Limpar os recursos

Quando você não precisar mais dos recursos criados por meio o Terraform, execute as seguintes etapas:

  1. Execute terraform plan e especifique o sinalizador destroy.

    terraform plan -destroy -out main.destroy.tfplan

    Pontos principais:

    • O comando terraform plan cria um plano de execução, mas não o executa. Em vez disso, ele determina quais ações são necessárias para criar a configuração especificada em seus arquivos de configuração. Esse padrão permite que você verifique se o plano de execução corresponde às suas expectativas antes de fazer qualquer alteração nos recursos reais.
    • O parâmetro opcional -out permite que você especifique um arquivo de saída para o plano. Usar o parâmetro -out garante que o plano que você examinou seja exatamente o que é aplicado.

  2. Execute a aplicação do Terraform para aplicar o plano de execução.

    terraform apply main.destroy.tfplan

Solucionar problemas do Terraform no Azure

Solucionar problemas comuns ao usar o Terraform no Azure.

Próximas etapas

Criar API em branco e simular respostas de API.