O runtime Python 3.10 agora disponível no AWS Lambda

Por Suresh Poopandi, arquiteto sênior de soluções da Global Life Sciences 

O AWS Lambda agora oferece suporte ao Python 3.10 como runtime gerenciado e imagem base de contêiner. Com essa versão, os desenvolvedores de Python agora podem aproveitar os novos recursos e melhorias introduzidos no Python 3.10 ao criar aplicativos serverless no Lambda.

Os aprimoramentos no Python 3.10 incluem correspondência de padrões estruturais, mensagens de erro aprimoradas e aprimoramentos de desempenho. Esta postagem descreve alguns dos benefícios do Python 3.10 e como usar essa versão em suas funções Lambda.

A AWS também publicou uma prévia da imagem base do contêiner Lambda para Python 3.11. Os clientes podem usar essa imagem para ver antecipadamente o suporte ao Python 3.11 no Lambda. Essa imagem está sujeita a alterações e não deve ser usada para cargas de trabalho de produção. Para fornecer feedback sobre essa imagem e para futuras atualizações sobre o suporte ao Python 3.11, consulte https://github.com/aws/aws-lambda-base-images/issues/62.

O que há de novo no Python 3.10

Graças à sua simplicidade, legibilidade e amplo suporte da comunidade, o Python é uma linguagem popular para criar aplicativos serverless. A versão 3.10 do Python inclui vários novos recursos, como:

• Correspondência de padrões estruturais (PEP 634): A correspondência de padrões estruturais é uma das adições mais significativas ao Python 3.10. Com a correspondência de padrões estruturais, os desenvolvedores podem usar padrões para comparar com estruturas de dados, como listas, tuplas e dicionários, e executar código com base na correspondência. Esse recurso permite que os desenvolvedores escrevam códigos que processam estruturas de dados complexas com mais facilidade e podem melhorar a legibilidade e a capacidade de manutenção do código.
• Gerenciadores de contexto entre parênteses (BPO-12782): O Python 3.10 introduz uma nova sintaxe para gerenciadores de contexto entre parênteses, facilitando a leitura e gravação de código que usa a instrução “with”. Esse recurso simplifica o gerenciamento de recursos, como identificadores de arquivos ou conexões de banco de dados, garantindo que eles sejam liberados corretamente.
• Escrevendo tipos de união como X | Y (PEP 604): O Python 3.10 permite escrever tipos de união como X | Y em vez da sintaxe das versões anteriores de digitar Union [X, Y]. Os tipos de união representam um valor que pode ser de vários tipos. Essa alteração não afeta a funcionalidade do código e é compatível com versões anteriores, portanto, o código escrito com a sintaxe anterior ainda funcionará. A nova sintaxe visa reduzir o código padronizado e melhorar a legibilidade e a capacidade de manutenção do código Python, fornecendo uma sintaxe mais concisa e intuitiva para tipos de união.
• Protetores de tipo definidos pelo usuário (PEP 647): os protetores de tipo definidos pelo usuário permitem que os desenvolvedores definam seus próprios protetores de tipo para lidar com tipos de dados personalizados ou refinar os tipos de tipos incorporados. Os desenvolvedores podem definir suas próprias funções que realizam verificações de tipo mais complexas como protetores de digitação definidos pelo usuário. Esse recurso melhora a legibilidade, a capacidade de manutenção e a correção do código Python, especialmente em projetos com estruturas de dados complexas ou tipos de dados personalizados.
• Mensagens de erro aprimoradas: o Python 3.10 aprimorou as mensagens de erro, fornecendo aos desenvolvedores mais informações sobre a origem do erro e sugerindo possíveis soluções. Isso ajuda os desenvolvedores a identificar e corrigir problemas mais rapidamente. As mensagens de erro aprimoradas no Python 3.10 incluem mais contexto sobre o erro, como o número da linha e o local em que o erro ocorreu, bem como a natureza exata do erro. Além disso, as mensagens de erro do Python 3.10 agora fornecem mais informações úteis sobre como corrigir o erro, como sugestões de sintaxe ou uso corretos.

Melhorias de desempenho

A convenção de chamada vetorial PEP 590 mais rápida permite chamadas de função Python mais rápidas e eficientes, especialmente aquelas que usam vários argumentos. As funções internas específicas que se beneficiam dessa otimização incluem map (), filter (), reversed (), bool () e float (). Ao usar a convenção de chamada vectorcall, de acordo com as notas de lançamento do Python 3.10, o desempenho dessas funções embutidas melhorou em um fator de 1,26x.

Quando uma função é definida com anotações, elas são armazenadas em um dicionário que mapeia os nomes dos parâmetros para suas respectivas anotações. Nas versões anteriores do Python, esse dicionário foi criado imediatamente quando a função foi definida. No entanto, no Python 3.10, esse dicionário é criado somente quando as anotações são acessadas, o que pode acontecer quando a função é chamada. Ao atrasar a criação do dicionário de anotações até que seja necessário, o Python pode evitar a sobrecarga de criar e inicializar o dicionário durante a definição da função. Isso pode resultar em uma redução significativa no tempo de CPU, pois a criação do dicionário pode ser uma operação demorada, especialmente para funções com muitos parâmetros ou anotações complexas.

No Python 3.10, a instrução LOAD_ATTR, responsável por carregar atributos de objetos no código, foi aprimorada com um novo mecanismo chamado “per opcode cache”. Esse mecanismo funciona armazenando atributos acessados com frequência em um cache específico para cada instrução LOAD_ATTR, o que reduz a necessidade de pesquisas repetidas de atributos. Como resultado dessa melhoria, de acordo com as notas de lançamento do Python 3.10, a instrução LOAD_ATTR agora é aproximadamente 36% mais rápida ao acessar atributos regulares e 44% mais rápida ao acessar atributos definidos usando o mecanismo de slots.

Em Python, os construtores str (), bytes () e bytearray () são usados para criar novas instâncias desses tipos a partir de dados ou valores existentes. Com base no resultado dos testes de desempenho conduzidos como parte do BPO-41334, os construtores str (), bytes () e bytearray () são cerca de 30 a 40% mais rápidos para objetos pequenos.

As funções Lambda desenvolvidas com Python que leem e processam arquivos compactados Gzip podem obter uma melhoria de desempenho. Adicionar _blocksOutputBuffer ao módulo bz2/lzma/zlib eliminou a sobrecarga de redimensionar os buffers bz2/lzma, evitando o consumo excessivo de memória do buffer zlib. De acordo com as notas de lançamento do Python 3.10, a descompressão bz2 agora é 1,09x mais rápida, a descompressão lzma 1,20x mais rápida e a leitura do GZipFile é 1,11x mais rápida

Usando o Python 3.10 no Lambda

Console de gerenciamento da AWS

Para usar o tempo de execução do Python 3.10 para desenvolver suas funções do Lambda, especifique um valor de parâmetro de tempo de execução Python 3.10 ao criar ou atualizar uma função. A versão Python 3.10 agora está disponível no menu suspenso Runtime na página Criar função.

Para atualizar uma função Lambda existente para o Python 3.10, navegue até a função no console do Lambda e escolha Editar no painel de configurações do Runtime. A nova versão do Python está disponível no menu suspenso Runtime:

AWS Serverless Application Model (AWS SAM)

No AWS SAM, defina o atributo Runtime como python3.10 para usar essa versão.

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Simple Lambda Function
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      Description: My Python Lambda Function
      CodeUri: my_function/
      Handler: lambda_function.lambda_handler
      Runtime: python3.10

O AWS SAM oferece suporte à geração desse modelo com o Python 3.10 pronto para uso para novos aplicativos serverless usando o comando sam init. Consulte a documentação do AWS SAM aqui.

Kit de desenvolvimento de nuvem da AWS (AWS CDK)

No AWS CDK, defina o atributo de tempo de execução como runtime.python_3_10 para usar essa versão. Em Python:

from constructs import Construct
from aws_cdk import (
    App, Stack,
    aws_lambda as _lambda
)


class SampleLambdaStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        base_lambda = _lambda.Function(self, 'SampleLambda',
                                       handler='lambda_handler.handler',
                                       runtime=_lambda.Runtime.PYTHON_3_10,
                                       code=_lambda.Code.from_asset('lambda'))

Em TypeScript:

import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda'
import * as path from 'path';
import { Construct } from 'constructs';

export class CdkStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // The code that defines your stack goes here

    // The python3.10 enabled Lambda Function
    const lambdaFunction = new lambda.Function(this, 'python310LambdaFunction', {
      runtime: lambda.Runtime.PYTHON_3_10,
      memorySize: 512,
      code: lambda.Code.fromAsset(path.join(__dirname, '/../lambda')),
      handler: 'lambda_handler.handler'
    })
  }
}

AWS Lambda — Imagem de contêiner

Altere a versão da imagem base do Python modificando a instrução FROM no Dockerfile:

FROM public.ecr.aws/lambda/python:3.10

# Copy function code
COPY lambda_handler.py ${LAMBDA_TASK_ROOT}

Para saber mais, consulte a guia de uso sobre como criar funções como imagens de contêiner.

Conclusão

Você pode criar e implantar funções usando o Python 3.10 usando o Console de Gerenciamento da AWS, o AWS CLI, o AWS SDK, o AWS SAM, o AWS CDK ou a Infraestrutura como Código (IaC) de sua escolha. Você também pode usar a imagem base de contêiner do Python 3.10 se preferir criar e implantar suas funções usando imagens de contêiner.

Estamos empolgados em trazer o suporte de tempo de execução do Python 3.10 para o Lambda e capacitar os desenvolvedores a criar aplicativos serverless mais eficientes, poderosos e escaláveis. Experimente o tempo de execução do Python 3.10 no Lambda hoje, experimente os benefícios dessa versão atualizada da linguagem e aproveite o desempenho aprimorado.

Para obter mais recursos de aprendizado serverless, visite Serverless Land.