M

MLOG

Português

Desvende o poder serverless com Google Cloud Functions. Este guia explora gatilhos HTTP, capacitando desenvolvedores globais a construir apps escaláveis e orientadas a eventos.

Google Cloud Functions: Um Guia Abrangente para Gatilhos HTTP

Google Cloud Functions (GCF) é um ambiente de execução serverless que permite construir e conectar serviços em nuvem. Com o Cloud Functions, você escreve funções simples e de propósito único que são anexadas a eventos emitidos da sua infraestrutura e serviços em nuvem. Sua função é executada quando o evento que você está monitorando ocorre. Essa abordagem permite desenvolver aplicações orientadas a eventos sem gerenciar servidores ou runtimes.

Uma das formas mais comuns de acionar uma Cloud Function é através de uma requisição HTTP. Este guia irá aprofundar-se no mundo dos gatilhos HTTP no Google Cloud Functions, fornecendo-lhe o conhecimento para construir aplicações poderosas, escaláveis e econômicas.

O que são Gatilhos HTTP?

Um gatilho HTTP permite que você execute sua Cloud Function em resposta a uma requisição HTTP. Essencialmente, quando uma requisição HTTP é enviada para uma URL específica, o Google Cloud Functions executará automaticamente a função associada. Isso torna os gatilhos HTTP ideais para construir APIs, webhooks e aplicações web orientadas a eventos.

Principais Benefícios de Usar Gatilhos HTTP:

Criando uma Cloud Function com um Gatilho HTTP

Vamos percorrer o processo de criação de uma Cloud Function simples com um gatilho HTTP. Criaremos uma função que responde com uma mensagem "Hello, World!". Este exemplo pode ser adaptado para várias localidades globais simplesmente modificando a string de saída.

Pré-requisitos:

Passos:

  1. Crie um Novo Projeto (se você não tiver um):

    Se você ainda não tem um projeto GCP, crie um no Google Cloud Console.

  2. Habilite a API do Cloud Functions:

    No Cloud Console, navegue até a API do Cloud Functions e habilite-a.

  3. Crie um Diretório de Função:

    Crie um novo diretório para sua Cloud Function. Por exemplo:

    mkdir hello-http
cd hello-http
  4. Escreva o Código da Função:

    Crie um arquivo chamado `main.py` (ou `index.js` para Node.js) com o seguinte código:

    Python (main.py):

    def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        .
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'name' in request_json:
        name = request_json['name']
    elif request_args and 'name' in request_args:
        name = request_args['name']
    else:
        name = 'World'
    return f'Hello, {name}!'

    Node.js (index.js):

    exports.helloHttp = (req, res) => {
  let name = 'World';
  if (req.body.name) {
    name = req.body.name;
  } else if (req.query.name) {
    name = req.query.name;
  }
  res.status(200).send(`Hello, ${name}!`);
};
  5. Crie um Arquivo de Requisitos (apenas Python):

    Se você estiver usando Python, crie um arquivo chamado `requirements.txt` e adicione quaisquer dependências que sua função precise. Para este exemplo, não é estritamente necessário, mas é uma boa prática incluí-lo. Você pode deixá-lo vazio se não tiver nenhuma dependência.

  6. Implante a Função:

    Use o comando `gcloud functions deploy` para implantar sua função. Substitua `YOUR_FUNCTION_NAME` pelo nome desejado para sua função.

    Python:

    gcloud functions deploy YOUR_FUNCTION_NAME \\
    --runtime python39 \\
    --trigger-http \\
    --allow-unauthenticated

    Node.js:

    gcloud functions deploy YOUR_FUNCTION_NAME \\
    --runtime nodejs16 \\
    --trigger-http \\
    --allow-unauthenticated

    Explicação dos parâmetros:

    • `YOUR_FUNCTION_NAME`: O nome que você deseja dar à sua Cloud Function.
    • `--runtime`: O ambiente de execução para sua função (por exemplo, `python39`, `nodejs16`).
    • `--trigger-http`: Especifica que a função deve ser acionada por requisições HTTP.
    • `--allow-unauthenticated`: Permite que qualquer pessoa invoque a função sem autenticação. Aviso: Tenha cautela ao habilitar isso em ambientes de produção! Considere implementar autenticação e autorização adequadas.
  7. Teste a Função:

    Após a implantação, o comando `gcloud` exibirá a URL da sua função. Você pode então testá-la enviando uma requisição HTTP para essa URL usando uma ferramenta como `curl` ou Postman.

    curl YOUR_FUNCTION_URL

    Você deverá ver a "Hello, World!" mensagem na resposta. Você também pode passar um nome como parâmetro de consulta:

    curl \"YOUR_FUNCTION_URL?name=YourName\"

    Isso deve retornar "Hello, YourName!"

Compreendendo a Requisição e Resposta HTTP

Quando uma Cloud Function é acionada por uma requisição HTTP, ela recebe um objeto contendo informações sobre a requisição. Este objeto geralmente inclui:

Sua função deve então retornar uma resposta HTTP, que inclui:

Exemplo: Lidando com Diferentes Métodos HTTP

Aqui está um exemplo de como lidar com diferentes métodos HTTP em sua Cloud Function:

Python (main.py):

from flask import escape

def http_method(request):
    """Responde a qualquer requisição HTTP.
    Args:
        request (flask.Request): Objeto da requisição HTTP.
    Returns:
        O texto da resposta, ou qualquer conjunto de valores que podem ser transformados em um
        objeto Response usando
        `make_response`.
    """
    if request.method == 'GET':
        return 'Esta é uma requisição GET!'
    elif request.method == 'POST':
        request_json = request.get_json(silent=True)
        if request_json and 'message' in request_json:
            message = escape(request_json['message'])
            return f'Esta é uma requisição POST com mensagem: {message}'
        else:
            return 'Esta é uma requisição POST sem mensagem.'
    else:
        return 'Método HTTP não suportado.', 405

Node.js (index.js):

exports.httpMethod = (req, res) => {
  switch (req.method) {
    case 'GET':
      res.status(200).send('Esta é uma requisição GET!');
      break;
    case 'POST':
      if (req.body.message) {
        const message = req.body.message;
        res.status(200).send(`Esta é uma requisição POST com mensagem: ${message}`);
      } else {
        res.status(200).send('Esta é uma requisição POST sem mensagem.');
      }
      break;
    default:
      res.status(405).send('Método HTTP não suportado!');
      break;
  }
};

Lembre-se de implantar a função atualizada usando o comando `gcloud functions deploy`.

Protegendo Seus Gatilhos HTTP

A segurança é fundamental ao trabalhar com gatilhos HTTP, especialmente ao lidar com dados sensíveis ou operações críticas. Aqui estão algumas considerações importantes de segurança:

Autenticação e Autorização

Por padrão, as Cloud Functions acionadas por HTTP são acessíveis publicamente se você usar `--allow-unauthenticated`. Na maioria dos cenários de produção, você vai querer restringir o acesso a usuários ou serviços autorizados. O Google Cloud oferece várias opções para autenticação e autorização:

Validação de Entrada

Sempre valide os dados de entrada recebidos por sua Cloud Function para prevenir vulnerabilidades de segurança como injeção de SQL ou cross-site scripting (XSS). Use técnicas apropriadas de sanitização e escape para proteger contra entradas maliciosas.

HTTPS

Garanta que sua Cloud Function seja acessível apenas via HTTPS para criptografar a comunicação entre o cliente e a função. O Google Cloud Functions fornece endpoints HTTPS automaticamente.

Limitação de Taxas

Implemente limitação de taxas para prevenir abusos e ataques de negação de serviço (DoS). Você pode usar serviços como o Google Cloud Armor para proteger suas Cloud Functions de tráfego excessivo.

Casos de Uso para Gatilhos HTTP

Os gatilhos HTTP são versáteis e podem ser usados em uma ampla gama de aplicações. Aqui estão alguns casos de uso comuns:

Exemplos em Diferentes Indústrias

Técnicas Avançadas

Usando Variáveis de Ambiente

Variáveis de ambiente permitem que você configure sua Cloud Function sem codificar informações sensíveis ou valores de configuração diretamente em seu código. Você pode definir variáveis de ambiente usando o comando `gcloud functions deploy` ou no Google Cloud Console.

gcloud functions deploy YOUR_FUNCTION_NAME \\
    --runtime python39 \\
    --trigger-http \\
    --set-env-vars API_KEY=YOUR_API_KEY,DATABASE_URL=YOUR_DATABASE_URL

Em seu código, você pode acessar variáveis de ambiente usando o dicionário `os.environ` (Python) ou o objeto `process.env` (Node.js).

Python:

import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Use a chave de API em sua função
    return f'API Key: {api_key}'

Node.js:

exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Use a chave de API em sua função
  res.status(200).send(`API Key: ${apiKey}`);
};

Lidando com Tarefas Assíncronas

Para tarefas de longa duração ou computacionalmente intensivas, é melhor usar processamento assíncrono para evitar o bloqueio da requisição HTTP. Você pode usar serviços como Google Cloud Tasks ou Cloud Pub/Sub para descarregar essas tarefas para filas separadas.

Tratamento de Erros e Registro de Logs

Implemente tratamento de erros e registro de logs robustos em suas Cloud Functions para identificar e resolver problemas rapidamente. Use o Google Cloud Logging para coletar logs de suas funções e monitorar seu desempenho.

Boas Práticas

Solução de Problemas Comuns

Conclusão

Google Cloud Functions com gatilhos HTTP oferece uma maneira poderosa e flexível de construir aplicações serverless. Ao compreender os conceitos e técnicas discutidos neste guia, você pode aproveitar o poder das Cloud Functions para criar soluções escaláveis, econômicas e orientadas a eventos para um público global. Abrace a revolução serverless e desbloqueie todo o potencial de suas aplicações em nuvem!