:Comparação e compatibilidade entre Function Compute 3.0 e Function Compute 2.0

As configurações dos serviços e funções originais permanecem inalteradas. As funções originais ainda podem ser invocadas conforme o esperado. Por exemplo, a concorrência de instância configurada para uma função no Function Compute 2.0 continua válida no Function Compute 3.0. No entanto, funções criadas nos runtimes padrão do Function Compute 3.0 não suportam mais o recurso de concorrência de instância. Para obter informações sobre a compatibilidade do Function Compute 3.0 com serviços e funções originais, consulte Compatibilidade com serviços e funções originais.

No Function Compute, crie funções sem a necessidade de criar serviços. As configurações que antes eram feitas no nível do serviço, como funções (roles), logging e VPCs, agora são configuradas diretamente na função. O código de exemplo a seguir mostra uma configuração de função usando o Function Compute SDK for Go:

resp, err := client.CreateFunction(
    new(fc.CreateFunctionRequest).
        SetBody(&fc.CreateFunctionInput{
            FunctionName: &funcName,
            Runtime:      tea.String("nodejs12"),
            Handler:      tea.String("index.handler"),
            MemorySize:   tea.Int32(128),
            Role:         tea.String("role-arn"),
            VpcConfig: &fc.VPCConfig{
                VpcId:           tea.String("vpc-id"),
                VSwitchIds:      []*string{tea.String("vsw-id")},
                SecurityGroupId: tea.String("sg-id"),
            },
            Code: new(fc.InputCodeLocation).SetZipFile(fx.GetCodeZipBase64()),
        }))

event := "my event"
resp, err = client.InvokeFunction(&funcName,
    new(fc.InvokeFunctionRequest).SetBody(strings.NewReader(event)))
body, err := ioutil.ReadAll(resp.Body)

O código de exemplo a seguir demonstra como publicar uma versão e criar um alias para uma função utilizando o Function Compute SDK for Go:

resp, err := client.PublishFunctionVersion(&funcName,
    new(fc.PublishFunctionVersionRequest).SetBody(&fc.PublishVersionInput{
        Description: tea.String("version desc"),
    }))

aliasName := "my-alias"
routingConfig := map[string]*float32{
    "2": tea.Float32(float32(0.05)),
}

resp, err := client.CreateAlias(&funcName, new(fc.CreateAliasRequest).
    SetBody(&fc.CreateAliasInput{
        AliasName:               &aliasName,
        VersionId:               tea.String("1"),
        AdditionalVersionWeight: routingConfig,
    }))

No Function Compute 3.0, os handlers para requisições de eventos e HTTP foram unificados. O exemplo de código a seguir ilustra esse comportamento em Python:

def handler(event, context):
    return 'hello fc'

O Function Compute converte as requisições que acessam funções por meio das URLs de gatilhos HTTP ou nomes de domínio personalizados em eventos e transforma as respostas das funções em respostas HTTP.

Veja abaixo um exemplo de requisição de evento:

{
    "version": "v1",
    "rawPath": "/my/path",
    "httpMethod": "POST",
    "headers": {
        "header1": "value1,value2",
        "header2": "value2"
    },
    "queryParameters": {
        "param1": "value1,value2",
        "param2": "value2"
    },
    "body": "hello from client",
    "isBase64Encoded": false,
    "requestContext": {
        "accountId": "12345678",
        "domainName": "my-domain.com",
        "domainPrefix": "prefix",
        "requestId": "abcd-efgh",
        "time": "2023-09-01T14:17:23+08:00",
        "timeEpoch": 1693549043255,
        "http": {
            "method": "GET",
            "path": "/my/path",
            "protocol": "http",
            "sourceIP": "39.40.41.42",
            "userAgent": "go-sdk/1.0"
        }
    }
}

Confira a seguir um exemplo de resposta HTTP:

def handler(event, context):
    return {
        'body': 'hello FC',
        'headers': {
            'my-custom-header': 'foo'
        },
        'statusCode': 400
    }

O código a seguir exibe a resposta HTTP convertida gerada pelo código anterior:

HTTP/1.1 400 Bad Request
Content-Type: text/plain; charset=utf-8
My-Custom-Header: foo
X-Fc-Request-Id: 64e866c9-69902fbc525fd10989e7299c
Date: Fri, 25 Aug 2023 10:18:06 GMT
Content-Length: 8

hello FC

Para detalhes sobre a conversão de formato de requisições e respostas, consulte Visão geral do gatilho HTTP.

Ao utilizar determinados recursos fornecidos pelo Function Compute, como logging, VPC e invocação assíncrona, o Function Compute precisa acessar outros serviços da Alibaba Cloud. Por exemplo, ao configurar o recurso de logging para uma função, conceda ao Function Compute permissões de gravação em um Logstore do Simple Log Service antes que ele possa escrever logs nesse Logstore. Em versões anteriores, as permissões de gravação em Logstores do Simple Log Service eram configuradas por meio de funções de serviço. Essas funções de serviço eram assumidas pelo Function Compute e pelo código da função para acessar outros serviços da Alibaba Cloud, o que poderia resultar na concessão de permissões excessivas.

No Function Compute 3.0, há suporte para funções vinculadas a serviço. Utilize essas funções para autorizar o Function Compute a acessar outros serviços da Alibaba Cloud. Caso seu código precise acessar outros serviços da Alibaba Cloud, utilize funções de função (function roles) para implementar a autorização. O Function Compute também permite gerenciar as permissões das funções de função de maneira granular, de acordo com as necessidades do seu negócio.

Após criar a função vinculada a serviço, as funções criadas no Function Compute 3.0 assumirão automaticamente essa função vinculada. Dessa forma, utilize recursos específicos, como logging, VPC e invocação assíncrona, sem precisar configurar funções (roles) manualmente para cada função.

O Function Compute 3.0 oferece um novo conjunto de operações de API e uma nova interface gráfica no console, mantendo total compatibilidade com os serviços e funções originais. A tabela a seguir descreve as regras de compatibilidade e apresenta exemplos para facilitar o entendimento. Nos exemplos, considere que você criou o serviço s1 contendo a função f1 e a função f2 no Function Compute 2.0. Além disso, a versão 1, a versão 2 e o alias prod foram criados para o serviço s1 no Function Compute 2.0.