Como automatizar implantações seguras do Lambda a partir do Git

O Lambda possui um editor de texto baseado na Web que você provavelmente já usou antes para escrever suas funções. É ótimo para iniciantes que aprendem a plataforma, mas não é a melhor maneira de lidar com atualizações. Veja como rastrear suas funções Lambda no Git.

Como o CI / CD para Lambda funciona

Em vez de usar o editor de manual, você deve desenvolver suas funções localmente, confirmar e enviar alterações para um repositório Git e fazer com que o CodePipeline lide com a construção e implantação para você.

O CodePipeline é executado automaticamente sempre que detecta alterações no seu controle de origem e envia as alterações para o CodeBuild (ou Jenkins) para construção. Esta etapa é opcional e você pode não usá-la no Lambda, mas se você estiver usando algo como TypeScript, precisará desse estágio. Após a construção, as alterações são enviadas para o CodeDeploy, que lida com a implantação.

O CodeDeploy atualiza automaticamente suas funções Lambda e envia uma nova versão. Para tornar o processo de implantação mais suave, ele pode mudar o tráfego gradualmente usando um alias, até que 100% do tráfego seja direcionado para a nova função.

Para lidar com a implantação real, o CodeDeploy usa o SAM (Serverless Application Model) da AWS. O SAM é uma extensão do CloudFormation, um serviço de infraestrutura como código. É basicamente um modelo de linguagem de serialização de dados legível por humanos (YAML) que é usado para lidar com toda a configuração associada à implantação de funções Lambda e seus pré-requisitos, e é uma parte vital da capacidade de implantar usando apenas código.

Configurando o controle de fonte

Este passo é bastante simples. Você deseja criar um novo diretório de projeto para armazenar todo o seu código e inicializá-lo com o Git. O modelo SAM irá para a raiz deste diretório, chamado template. yml. Cada função irá para sua própria pasta, com a raiz sendo index. js para cada uma. Isso claramente separa tudo e facilita o gerenciamento

 Diretório do Projeto | --template. yml | --Função | | --index. js | --AnotherFunction | --index. js 

CodePipeline suporta Github e BitBucket para controle de origem. Se você estiver usando um desses, tudo o que você precisará fazer é criar uma nova ramificação para implantações (ou simplesmente usar o mestre, se você estiver bem com isso). Se você estiver usando um serviço diferente, desejará usar o controle de origem CodeCommit da AWS como um repositório secundário, fazendo alterações sempre que desejar fazer atualizações. p>

Escrevendo um modelo de SAM

Este passo será o mais complicado e o mais específico para sua função e seus requisitos. Você precisará criar um modelo SAM que irá configurar sua função Lambda e todos os recursos necessários.

Um modelo básico é mais ou menos assim:

 AWSTemplateFormatVersion: '2010-09-09' Transformação: AWS :: Serverless-2016-10-31 Descrição: Um modelo de Especificação sem servidor da AWS que descreve sua função Recursos: HelloWorld: Tipo: AWS :: Serverless :: Function Propriedades: Manipulador: HelloWorld / index. handler Tempo de execução: nodejs8.10 

Isso registra um recurso, uma função Lambda, que é executada no NodeJS e tem seu manipulador no HelloWorld / index. js.

Você também pode implantar outros recursos do modelo SAM. Por exemplo, para conceder permissão ao API Gateway para chamar sua função e definir sua função para ser executada em um caminho específico da API, você deve adicionar o seguinte:

 AWSTemplateFormatVersion: '2010-09-09' Transformação: AWS :: Serverless-2016-10-31 Descrição: Um modelo de Especificação sem servidor da AWS que descreve sua função Recursos: HelloWorld: Tipo: AWS :: Serverless :: Function Propriedades: Manipulador: HelloWorld / index. handler Tempo de execução: nodejs8.10 Eventos: HelloWorldApi: Tipo: Api Propriedades: Caminho: / helloworld Método: GET HelloWorldPermission: Tipo: AWS :: Lambda :: Propriedades de permissão: Ação: lambda: InvokeFunction FunctionName: Fn :: GetAtt: - HelloWorld - Arn Principal: apigateway. amazonaws. com SourceArn: Fn :: Sub: arn: aws: execute-api: $: $: * / * / * / * 

Você definitivamente precisará de usos mais específicos do que os listados aqui; portanto, para obter mais informações sobre o SAM, leia nosso guia para trabalhar com ele, os guias do desenvolvedor da AWS ou o esquema completo no Github. .

Depois de ter um modelo de trabalho, você pode testar a implantação instalando o SAME CLIp>

 pip install aws-sam-cli 

Em seguida, você empacota seu projeto e armazena os artefatos em um bucket S3:

 sam package \ --template-file template. yml \ --output-template-file package. yml \ --s3-bucket bucket-name 

E você executará manualmente a implantação:

 sam deploy \ --template-file package. yml \ --stack-name sam-hello-world \ --capabilities CAPABILITY_IAM 

Se tudo funcionou corretamente, você deverá ver uma nova pilha do CloudFormation e um aplicativo no Lambda com suas funções.

Empacotando e implantando o projeto com o CodePipeline

Este estágio não é opcional, mesmo que você não esteja trabalhando com um idioma compilado. Usando o modelo SAM, o CodeBuild será usado aqui para manipular o empacotamento do projeto em algo que pode ser implantado com o CodeDeploy com muita facilidade. Opcionalmente, você pode executar outros comandos antes do empacotamento, como o npm run build e o npm install.

Primeiro, você precisará de uma função de execução capaz de lidar com as atualizações do CloudFormation. Abra o IAM Management Console para adicionar uma nova função. Selecione “ CloudFormation ” como o recurso que usará essa função, anexe a política de permissão “ AWSLambdaExecute.

Salve a função, abra-a e anexe a seguinte política embutida:

 {"Instrução": [{"Ação": ["apigateway: *", "codedeploy: *", "lambda: *", "cloudformation: CreateChangeSet", "iam: GetRole", "iam : CreateRole "," nome: DeleteRole "," nome: PutRolePolicy "," nome: AttachRolePolicy "," nome: DeleteRolePolicy "," nome: DetachRolePolicy "," nome: PassRole "," s3: GetObject "," s3: GetObjectVersion "," s3: GetBucketVersioning "]," Recurso ":" * "," Efeito ":" Permitir "}]," Versão ":" 17/10/2012 "} 

Crie um novo pipeline no console do CodePipeline. Escolha as configurações padrão para criar uma nova função de serviço. Isso será configurado automaticamente.

Para o estágio de controle de origem, escolha seu tipo de controle de origem, repo e release branch.

Para o estágio de construção, você desejará criar um novo projeto no CodeBuild. A configuração padrão é boa, basta escolher o Amazon Linux 2 como o sistema operacional de compilação e selecionar o tempo de execução e a imagem padrão.

A principal coisa que você precisará para o codePipeline é o seu arquivo buildspec. yml, colocado na raiz do diretório do seu projeto. Isso configura o CodeBuild com os comandos que ele precisa executar. A configuração a seguir é um exemplo que instala o TypeScript, todos os pacotes NPM, executa o npm run build e empacota tudo para o CloudFormation.

 versão: 0.2 fases: install: versões de tempo de execução: nodejs: 10 comandos: - npm install -g typescript build: comandos: - echo Build iniciado em `date` - npm build time - npm time de instalação - npm run build - export BUCKET = typescript-lambda - pacote aws cloudformation - modelo de arquivo de modelo. yml --s3-bucket $ BUCKET - arquivo de modelo de saída arquivo de saída outputtemplate. yml artefatos: tipo: arquivos zip: - template. yml - outputtemplate. yml [ /PRÉ]
 Você provavelmente precisará modificar isso para se adequar ao seu projeto. 
 Feito isso, você pode configurar o estágio final. Porém, em vez de usar o CodeDeploy, usaremos o CloudFormation para atualizar as coisas diretamente, pois todo o empacotamento aconteceu na fase de construção. Escolha “ CloudFormation ” como provedor de implantação e defina o modo de ação como "“ Crie ou substitua um conjunto de alterações". ” Digite um novo nome e altere o nome do conjunto. 
 Para o modelo, selecione “ BuildArtifact & ” e digite outputtemplate. yml na etapa anterior. Adicione o “ Capacidade IAM ” aos recursos e selecione a função de serviço que você criou manualmente anteriormente. 
 
 
 Clique em “ Criar ” e seu pipeline deve ser executado sem erros. No entanto, o estágio CloudFormation faz um conjunto de alterações, que é como uma visualização das mudanças. Para realmente implantar as alterações, precisamos executar o conjunto de alterações. 
 Clique em "Editar" ” no seu pipeline criado. Em “ Implantar; ” clique em 'Editar', ” e clique em “ Adicionar Grupo de Ação ” após a ação já criada. Se você criar a nova ação antes desta, ela não funcionará. 
 
 
 Escolha & CloudFormation ” como o provedor. Selecione “ BuildArtifact ” como o artefato de entrada. Para o modo de ação e alterar o nome do conjunto, insira os mesmos valores que você criou para a primeira ação de implantação. 
 
 
 Clique em 'Salvar', ” e você será levado de volta à tela principal do pipeline. Clique em "Liberar alteração" ” para executar manualmente o pipeline novamente. Agora deve ser concluído e as alterações devem estar visíveis no console do Lambda. 
 
 
 Se você está recebendo erros, é bastante fácil localizar, pois você pode clicar em "Mais detalhes" ” ao lado da mensagem de erro no CodePipeline. É provável que seja uma construção com falha, um modelo SAM incompleto ou permissões insuficientes para CodeBuild ou CloudFormation. 
 Se você confirmar alterações no seu controle de origem, ele deverá ser detectado pelo CodePipeline e iniciar todo esse processo novamente. 
Via: How to Geek