Function Compute:Visão geral do gatilho HTTP

exports.handler = (event, context, callback) => {
  const method = JSON.parse(event).requestContext.http.method;
  if (method === 'OPTIONS') {
    const fcResponse = {
      statusCode: 204,
      headers: {
        'Access-Control-Allow-Origin': 'http://www.fc.com',
        'Access-Control-Allow-Methods': 'POST',
        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
        'Access-Control-Max-Age': '3600'
      },
      body: ''
    };
    callback(null, fcResponse);
  } else {
    callback(null, {
      statusCode: 200,
      body: 'hello world'
    });
  }
};

import json

def handler(event, context):
    evt = json.loads(event)
    method = evt.get('requestContext', {}).get('http', {}).get('method', '')
    if method == 'OPTIONS':
        return {
            'statusCode': 204,
            'headers': {
                'Access-Control-Allow-Origin': 'http://www.fc.com',
                'Access-Control-Allow-Methods': 'POST',
                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
                'Access-Control-Max-Age': '3600'
            },
            'body': ''
        }
    return {
        'statusCode': 200,
        'body': 'hello world'
    }

package main

import (
    "context"
    "encoding/json"
)

type HttpRequest struct {
    RequestContext struct {
        Http struct {
            Method string `json:"method"`
        } `json:"http"`
    } `json:"requestContext"`
}

type HttpResponse struct {
    StatusCode int               `json:"statusCode"`
    Headers    map[string]string `json:"headers"`
    Body       string            `json:"body"`
}

func Handler(ctx context.Context, event []byte) (*HttpResponse, error) {
    var req HttpRequest
    if err := json.Unmarshal(event, &req); err != nil {
        return nil, err
    }
    if req.RequestContext.Http.Method == "OPTIONS" {
        return &HttpResponse{
            StatusCode: 204,
            Headers: map[string]string{
                "Access-Control-Allow-Origin":  "http://www.fc.com",
                "Access-Control-Allow-Methods": "POST",
                "Access-Control-Allow-Headers": "Content-Type, Authorization",
                "Access-Control-Max-Age":       "3600",
            },
            Body: "",
        }, nil
    }
    return &HttpResponse{StatusCode: 200, Body: "hello world"}, nil
}

Parâmetros de configuração de CORS

Valores para allowOrigins:

• *: Permite todas as origens (apenas quando allowCredentials é false).

• https://*: Permite todas as origens que começam com https://.

• Domínio específico: https://example.com.

• Múltiplos domínios: ["https://example.com", "https://app.example.com"].

• Wildcards de subdomínio (por exemplo, https://*.example.com) não são suportados. Liste todos os domínios explicitamente.

Valores para allowMethods:

• Métodos HTTP padrão: GET, POST, PUT, DELETE, PATCH, HEAD.

• *: Permite todos os métodos.

• Não inclua OPTIONS — o gateway gerencia todas as requisições preflight automaticamente.

Como o gateway trata as requisições

Requisições preflight (OPTIONS)

O gateway valida os cabeçalhos Origin, Access-Control-Request-Method e Access-Control-Request-Headers:

• Validação aprovada: Retorna 204 No Content com os cabeçalhos CORS configurados. Não invoca a função.

• Falha na validação:

  • A origem corresponde, mas outros cabeçalhos não: O gateway define cabeçalhos CORS básicos e encaminha a requisição para a função.

  • A origem não corresponde: Nenhum cabeçalho CORS é definido. A requisição é encaminhada para a função.

Requisições simples (GET, POST, HEAD, etc.)

O gateway valida apenas o cabeçalho Origin:

• Validação aprovada: Injeta Access-Control-Allow-Origin e outros cabeçalhos CORS na resposta. Encaminha a requisição para a função.

• Falha na validação: Não injeta cabeçalhos CORS. Ainda assim, encaminha a requisição para a função.

Prioridade

Quando múltiplos métodos de tratamento de CORS se aplicam ao mesmo caminho, o gateway os aplica nesta ordem:

1. CORS configurado via API (maior prioridade): Se ativado, o gateway aplica esta configuração primeiro.

2. CORS padrão: Se o CORS configurado via API estiver desativado, o gateway usa o comportamento padrão integrado de replicação.

3. CORS definido pela função: Os cabeçalhos retornados pela sua função são mesclados com os resultados acima.