Partilhar via

Tutorial: criar e publicar um produto

  • Artigo

APLICA-SE A: Todas as camadas de 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. Depois que um produto é publicado, os desenvolvedores podem assiná-lo e começar a usar as APIs do produto.

Neste tutorial, irá aprender a:

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

Produtos de gerenciamento de API no portal

Pré-requisitos

Criar e publicar um produto

  1. Entre no portal do Azure e navegue até sua instância de 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
    Display name O nome como você deseja que ele seja mostrado no portal do desenvolvedor.
    Description Forneça informações sobre o produto, como sua finalidade, as APIs às quais ele fornece acesso e outros detalhes.
    Estado Selecione Publicado se quiser publicar o produto no portal do desenvolvedor. Antes que as APIs de um produto possam ser descobertas pelos desenvolvedores, o produto deve ser publicado. Por padrão, os novos produtos não são publicados.
    Exige subscrição Selecione se um usuário precisa se inscrever para usar o produto (o produto está protegido) e uma chave de assinatura deve ser usada para acessar as APIs do produto. Se não for necessária uma subscrição (o produto está aberto), não é necessária uma chave de subscrição para aceder às APIs do produto. Consulte Acesso às APIs do produto mais adiante neste artigo.
    Requer aprovação Selecione se pretende que um administrador reveja e aceite ou rejeite tentativas de subscrição deste produto. Se não for selecionada, as tentativas de assinatura serão aprovadas automaticamente.
    Limite da contagem de subscrições Opcionalmente, limite a contagem de várias assinaturas simultâneas.
    Termos legais Pode incluir os termos de utilização do produto, que os subscritores têm de aceitar para poderem utilizar o produto.
    APIs Selecione uma ou mais APIs. Você também pode adicionar APIs depois de criar o produto. Para obter mais informações, consulte Adicionar APIs a um produto mais adiante neste artigo.

    Se o produto estiver aberto (não requer uma subscrição), só pode adicionar uma API que não esteja associada a outro produto aberto.

  4. Selecione Criar para criar seu novo produto.

Atenção

Tenha cuidado ao configurar um produto que não requer uma assinatura. Essa configuração pode ser excessivamente permissiva e pode tornar 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 de Gerenciamento de API, selecione o produto na janela Produtos . Adicionar ou atualizar:

Item Description
Definições Metadados e estado do produto
APIs APIs associadas ao produto
Políticas Políticas aplicadas a APIs de produtos
Controlo de acesso Visibilidade do produto para desenvolvedores ou convidados
Subscrições Subscritores do produto

Adicionar APIs a um produto

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

Adicionar uma API a um produto existente

  1. Na navegação à esquerda da instância de Gerenciamento de API, selecione Produtos.
  2. Selecione um produto e, em seguida, selecione APIs.
  3. Selecione + Adicionar API.
  4. Selecione uma ou mais APIs e, em seguida , Selecionar.

Adicionar uma API a um produto existente

Acesso às APIs do produto

Depois de publicar um produto, os desenvolvedores podem acessar as APIs. Dependendo de como o produto está configurado, eles podem precisar assinar o produto para acesso.

  • Produto protegido - Os programadores têm primeiro de subscrever um produto protegido para terem acesso às APIs do produto. Quando se inscrevem, recebem uma chave de subscrição que pode aceder a qualquer API desse produto. Se você criou a instância de Gerenciamento de API, já é um administrador, portanto, está inscrito em todos os produtos por padrão. Para obter mais informações, consulte 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. Políticas e regras de controle de acesso configuradas para o produto podem ser aplicadas.

    Gorjeta

    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 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 do cliente às APIs, incluindo OAuth 2.0, certificados de cliente e restrição de endereços IP do chamador.

    Nota

    Os produtos abertos não estão listados no portal do desenvolvedor para que os desenvolvedores conheçam ou se inscrevam. Eles são visíveis apenas para o grupo Administradores . Você precisará usar outro mecanismo para informar os desenvolvedores sobre 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, no máximo, a um produto aberto.

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

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

Próximos passos

Neste tutorial, ficou a saber como:

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

Avance para o tutorial seguinte:

Criar API em branco e simular respostas da API

Neste artigo, você usa 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.

Terraform permite a definição, visualização e implantação de infraestrutura em nuvem. Usando Terraform, você cria arquivos de configuração usando a sintaxe HCL. A sintaxe HCL permite especificar 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 na infraestrutura antes que elas sejam implantadas. Depois de verificar as alterações, você aplica o plano de execução para implantar a infraestrutura.

  • Especifique a versão necessária do Terraform e os 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 da definição da 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.
  • Produza 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 Terraform

Nota

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

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

  1. Crie um diretório no qual testar e executar o código Terraform de exemplo e torná-lo o diretório atual.

  2. Crie um arquivo chamado main.tfe insira o seguinte código:

    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.tfe insira o seguinte código:

    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.tfe insira o seguinte código:

    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.tfe insira o seguinte código:

    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     = "http://conferenceapi.azurewebsites.net/?format=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 o Terraform

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

terraform init -upgrade

Pontos principais:

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

Criar um plano de execução do Terraform

Execute o plano de terraforma para criar um plano de execução.

terraform plan -out main.tfplan

Pontos principais:

  • O terraform plan comando 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 quaisquer alterações nos recursos reais.
  • O parâmetro opcional -out permite especificar um arquivo de saída para o plano. O uso do -out parâmetro garante que o plano revisado seja exatamente o que é aplicado.

Aplicar um plano de execução Terraform

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

terraform apply main.tfplan

Pontos principais:

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

Verificar os resultados

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


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

Clean up resources (Limpar recursos)

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

  1. Execute o plano de terraforma e especifique o destroy sinalizador.

    terraform plan -destroy -out main.destroy.tfplan

    Pontos principais:

    • O terraform plan comando 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 quaisquer alterações nos recursos reais.
    • O parâmetro opcional -out permite especificar um arquivo de saída para o plano. O uso do -out parâmetro garante que o plano revisado seja exatamente o que é aplicado.

  2. Execute terraform apply para aplicar o plano de execução.

    terraform apply main.destroy.tfplan

Solucionar problemas do Terraform no Azure

Solucione problemas comuns ao usar o Terraform no Azure.

Próximos passos

Crie respostas de API em branco e de API simuladas.