Gerenciar APIs serverless com Apache APISIX

A computação sem servidor permite que os desenvolvedores criem aplicativos mais rapidamente, eliminando a necessidade de gerenciar infraestrutura. Com APIs sem servidor na nuvem, o provedor de serviços em nuvem provisiona, escala e gerencia automaticamente a infraestrutura necessária para executar o código. Neste artigo, você aprenderá como integrar o Apache APISIX API Gateway com o Azure Functions para gerenciar APIs sem servidor baseadas em Java.

Objetivos de aprendizagem

Ao longo do artigo, você aprenderá o seguinte:

• O que são APIs sem servidor?
• O papel do API Gateway no gerenciamento de tráfego complexo de APIs sem servidor.
• Como configurar o Apache APISIX Gateway.
• Como criar APIs sem servidor com o Azure Functions.
• Como expor APIs sem servidor como serviços upstream.
• Como proteger APIs sem servidor com plugins de autenticação do APISIX.
• Como aplicar políticas de limitação de taxa.

O Apache APISIX oferece plugins adicionais que podem ser usados com outras soluções sem servidor, como o AWS Lambda.

Antes de começarmos a parte prática do tutorial, vamos revisar alguns conceitos.

O que são APIs sem servidor?

APIs sem servidor são iguais às APIs tradicionais, exceto que utilizam um backend sem servidor. Para empresas e desenvolvedores, a computação sem servidor significa que eles não precisam mais se preocupar com a manutenção de servidores ou com o dimensionamento de recursos de servidor para atender às demandas dos usuários. Além disso, as APIs sem servidor evitam o problema de dimensionamento, pois criam recursos de servidor toda vez que uma solicitação é feita. As APIs sem servidor reduzem a latência, pois são hospedadas em um servidor de origem. Por último, mas não menos importante, a computação sem servidor é muito mais econômica do que a alternativa tradicional, como a construção de microsserviços.

APIs sem servidor usando o Azure Functions

Um Azure Function é uma maneira simples de executar pequenos trechos de código na nuvem. Você não precisa se preocupar com a infraestrutura necessária para hospedar esse código. Você pode escrever a função em C#, Java, JavaScript, PowerShell, Python ou qualquer uma das linguagens listadas nas linguagens suportadas.

Com o Azure Functions, você pode criar rapidamente APIs HTTP para seus aplicativos web sem a dor de cabeça dos frameworks web. O Azure Functions é sem servidor, então você só é cobrado quando um endpoint HTTP é chamado. Quando os endpoints não estão sendo usados, você não é cobrado. Essas duas coisas combinadas tornam plataformas sem servidor como o Azure Functions uma escolha ideal para APIs onde você experimenta picos inesperados de tráfego.

API Gateway para gerenciamento de tráfego de APIs sem servidor

Um API Gateway é a parte fundamental de uma API sem servidor, pois é responsável pela conexão entre uma API definida e a função que lida com as solicitações para essa API. Há muitos benefícios do API Gateway na arquitetura de APIs baseadas em sem servidor. Além das funcionalidades principais do API Gateway, como autenticação, limitação de taxa, observabilidade, cache, entre outras, ele é capaz de invocar APIs sem servidor, assinar eventos e processá-los usando callbacks, além de encaminhar solicitações de autenticação para serviços de autorização externos com lógica de função sem servidor completamente personalizada.

Gerenciando APIs sem servidor com demonstração do Apache APISIX

Com conhecimento teórico suficiente em mente, agora podemos entrar em uma sessão prática. Usamos um projeto de exemplo apisix-manage-serverless-apis hospedado no GitHub. Você pode encontrar o código-fonte e os comandos curl de exemplo que usamos neste tutorial.

Para nosso mini-projeto, trabalharemos com duas funções simples do Azure escritas em Java que simulam nossas APIs sem servidor para os serviços de Produto e Avaliação.

Pré-requisitos

• Deve estar familiarizado com conceitos fundamentais de API
• Deve ter conhecimento prático do Azure Functions, por exemplo, este módulo de aprendizagem mostra como construir uma API HTTP usando a extensão do Azure Functions para o Visual Studio Code.
• Docker
• Conta do Azure
• CLI do Azure
• Java Developer Kit, pelo menos versão 8
• Maven
• Azure Functions Core Tools
• Visual Studio Code
• Azure Functions Core Tools (versão mínima 2.6.666)
• Extensão do Azure Functions para Visual Studio Code

Configuração do projeto

A primeira coisa é clonar o repositório do projeto do GitHub:

git clone https://github.com/Boburmirzo/apisix-manage-serverless-apis.git

Abra a pasta do projeto no seu editor de código favorito. O tutorial utiliza o VS Code.

Executando o Apache APISIX

Para executar o Apache APISIX e o Azure Functions localmente, siga estas etapas:

Abra uma nova janela de terminal e execute o comando docker compose up na pasta raiz do projeto:

docker compose up -d

O comando acima executará o Apache APISIX e o etcd junto com o Docker. Por exemplo, se o Docker Desktop estiver instalado na sua máquina, você poderá ver os contêineres em execução lá:

Instalamos o APISIX em nosso ambiente local nesta demonstração, mas você também pode implantá-lo no Azure e executá-lo em uma Instância de Contêiner do Azure. Veja o seguinte tutorial.

Executando o Azure Functions

Em seguida, navegue até a pasta /upstream:

mvn clean install
mvn azure-functions:run

As duas funções serão iniciadas em uma janela de terminal. Você pode solicitar ambas as APIs sem servidor no seu navegador:

Por exemplo:

Implantando o Azure Functions

Em seguida, implantamos o código das funções no Azure Function App executando o comando abaixo:

mvn azure-functions:deploy

Ou você pode simplesmente seguir este tutorial sobre como implantar o projeto de função no Azure

Observe que o nome do aplicativo de função é gerado aleatoriamente com base no seu artifactId, acrescido de um número gerado aleatoriamente. Nos comandos do tutorial, o nome do aplicativo de função serverless-apis é mencionado.

Apenas para garantir que nossa função funciona, podemos testar uma chamada de invocação solicitando diretamente sua URL no navegador:

https://serverless-apis.azurewebsites.net/api/products
https://serverless-apis.azurewebsites.net/api/reviews

Expondo APIs sem servidor no APISIX

Uma vez que a configuração esteja completa, agora exporemos as APIs sem servidor do Azure Functions como serviços upstream no APISIX. Para isso, precisamos criar uma nova Rota com o plugin azure-function habilitado para ambas as APIs de backend sem servidor de produtos e avaliações.

Se o plugin azure-function estiver habilitado em uma rota, o APISIX escuta as solicitações no caminho dessa rota e, em seguida, invoca o código remoto do Azure Function com os parâmetros dessa solicitação.

Criando uma Rota para Produtos

Para criar uma rota para a função de Produtos, execute o seguinte comando:

curl http://127.0.0.1:9180/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "name": "Criar uma rota com o plugin Azure function",
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/products",
            "ssl_verify": false
        }
    },
    "uri": "/products"
}'

Observe que definimos o atributo ssl_verify do plugin azure-functions como false para desabilitar a verificação SSL apenas para fins de demonstração. Você também pode habilitá-lo para realizar solicitações mais seguras do APISIX para o Azure Functions. Aprenda outros parâmetros de configuração.

Testando com uma solicitação curl

Podemos usar o curl para enviar uma solicitação, verificando se o APISIX escuta corretamente no caminho e encaminha a solicitação para o serviço upstream com sucesso:

curl -i -XGET http://127.0.0.1:9080/products
HTTP/1.1 200 OK
[
  {
    "id": 1,
    "name": "Product1",
    "description": "Description1"
  },
  {
    "id": 2,
    "name": "Product2",
    "description": "Description2"
  }
]

Ótimo! Recebemos uma resposta da API sem servidor real no Azure Function.

Em seguida, faremos uma configuração semelhante para a função avaliações.

Criando uma Rota para Avaliações e testando

Crie a segunda rota com o plugin Azure function habilitado:

curl http://127.0.0.1:9180/apisix/admin/routes/2 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/reviews",
            "ssl_verify": false
        }
    },
    "uri": "/reviews"
}'

Teste a resposta da API sem servidor:

curl -i -XGET http://127.0.0.1:9080/reviews

Nesta seção, introduzimos a nova rota e adicionamos o plugin azure-functions às nossas APIs sem servidor para que o APISIX possa invocar as funções remotas do Azure e gerenciar o tráfego. Nas próximas seções, aprenderemos como autenticar consumidores de API e aplicar políticas de tempo de execução, como limitação de taxa.

Protegendo APIs sem servidor com plugins de autenticação do APISIX

Até agora, nossas APIs sem servidor são públicas e acessíveis por usuários não autorizados. Nesta seção, habilitaremos o recurso de autenticação para impedir solicitações não autorizadas às APIs sem servidor.

O Apache APISIX pode verificar a identidade associada às solicitações de API por meio da validação de credenciais e tokens. Além disso, ele é capaz de determinar qual tráfego está autorizado a passar pela API para os serviços de backend. Você pode verificar todos os plugins de autenticação disponíveis.

Vamos criar um novo consumidor para nossas APIs sem servidor e adicionar o plugin basic-auth à rota existente para que apenas o usuário permitido possa acessá-las.

Criando um novo consumidor para APIs sem servidor

O comando abaixo criará nosso novo consumidor com suas credenciais, como nome de usuário e senha:

curl http://127.0.0.1:9180/apisix/admin/consumers -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "username": "consumer1",
    "plugins": {
        "basic-auth": {
            "username": "username1",
            "password": "password1"
        }
    }
}

Adicionando o plugin basic auth às rotas existentes de Produtos e Serviços

Agora configuramos o plugin basic-auth para as rotas, permitindo que o APISIX verifique o cabeçalho da solicitação com as credenciais do consumidor da API cada vez que as APIs são chamadas:

curl http://127.0.0.1:9180/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "name": "Criar uma rota com o plugin Azure function",
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/products",
            "ssl_verify": false
        },
        "basic-auth": {}
    },
    "uri": "/products"
}'

curl http://127.0.0.1:9180/apisix/admin/routes/2 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/reviews",
            "ssl_verify": false
        },
        "basic-auth": {}
    },
    "uri": "/reviews"
}'

Testando o plugin basic auth

Agora, se solicitarmos as APIs sem servidor sem as credenciais do usuário no cabeçalho, receberemos um erro de não autorizado:

curl -i http://127.0.0.1:9080/products
HTTP/1.1 401 Unauthorized

{"message":"Falta autorização na solicitação"}

O resultado é o esperado. Mas se fornecermos as credenciais corretas do usuário na solicitação e acessarmos o mesmo endpoint, ele deve funcionar bem:

curl -i -u username1:password1 http://127.0.0.1:9080/products
HTTP/1.1 200 OK

Validamos a identidade do cliente que tenta solicitar as APIs sem servidor usando o plugin de autenticação básica com a ajuda do Apache APISIX.

Aplicando políticas de limitação de taxa para APIs sem servidor

Nesta seção, protegeremos as APIs sem servidor de abusos aplicando uma política de limitação. No Apache APISIX Gateway, podemos aplicar a limitação de taxa para restringir o número de chamadas recebidas.

Aplicando e testando a política de limitação de taxa

Com as configurações de rota existentes para as funções de Produtos e Avaliações selecionadas, podemos aplicar uma política de limitação de taxa com o plugin limit-count para proteger nossa API de uso anormal. Limitaremos o número de chamadas de API para 2 por 60s por consumidor de API.

Para habilitar o plugin limit-count para a rota existente de Produtos, precisamos adicionar o plugin ao atributo de plugins em nossa configuração de rota Json:

curl http://127.0.0.1:9180/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "name": "Criar uma rota com o plugin Azure function",
    "plugins": {
        "azure-functions": {
            "function_uri": "https://serverless-apis.azurewebsites.net/api/products",
            "ssl_verify": false
        },
        "basic-auth": {},
        "limit-count": {
            "count": 2,
            "time_window": 60,
            "rejected_code": 403,
            "rejected_msg": "As solicitações estão muito frequentes, tente novamente mais tarde."
        }
    },
    "uri": "/products"
}'

O Apache APISIX lidará com as duas primeiras solicitações normalmente. No entanto, uma terceira solicitação no mesmo período retornará um código 403 HTTP Forbidden com nossa mensagem de erro personalizada:

HTTP/1.1 403 Forbidden

{"error_msg":"As solicitações estão muito frequentes, tente novamente mais tarde."}

Próximos passos

Neste artigo, aprendemos passo a passo como criar APIs sem servidor baseadas em Java com o Azure Functions e o Apache APISIX Gateway para gerenciar suas APIs ao longo de seu ciclo de vida completo, desde a exposição de APIs sem servidor como serviços upstream no APISIX até a proteção adequada e a aplicação de limitação de taxa para limitar o número de solicitações. Isso abre as portas para outros casos de uso de integração de API Gateway e APIs sem servidor.

Você pode explorar outras capacidades do APISIX Gateway encadeando vários plugins integrados para transformar solicitações, monitorar a disponibilidade, desempenho e uso de nossas APIs sem servidor, armazenar em cache respostas de API e evoluí-las ainda mais versionando APIs que ajudam a reduzir o tempo de desenvolvimento, aumentar a escalabilidade e economizar custos.

O Apache APISIX é uma solução de API Gateway totalmente de código aberto. Se você precisar de recursos mais avançados de gerenciamento de API para APIs sem servidor, pode usar o API7 Enterprise ou o API7 Cloud, que são alimentados pelo APISIX.

Recursos relacionados

• Azure Functions.

• Construindo APIs sem servidor com o Azure Functions.

• Criando uma função Java no Azure usando o Visual Studio Code.

• Executando o Apache APISIX na Instância de Contêiner do Microsoft Azure.

Conteúdo recomendado

• Como escolher o API Gateway certo.

• Por que o Apache APISIX é o melhor API Gateway?

• O que são políticas de API Gateway?.