As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Tutorial: Implemente uma função Lambda atualizada com o modelo CodeDeploy de aplicativo sem AWS servidor
<a name="tutorial-lambda-sam"></a>

AWS O SAM é uma estrutura de código aberto para criar aplicativos sem servidor. Ele transforma e expande a sintaxe YAML em um AWS SAM modelo em CloudFormation sintaxe para criar aplicativos sem servidor, como uma função Lambda. Para obter mais informações, consulte [O que é o AWS Serverless Application Model?](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) 

 Neste tutorial, você usa o AWS SAM para criar uma solução que faça o seguinte: 
+  Cria sua função do Lambda. 
+  Cria seu CodeDeploy aplicativo e seu grupo de implantação. 
+  Cria duas funções Lambda que executam testes de validação de implantação durante os ganchos do ciclo de CodeDeploy vida. 
+  Detecta quando a função do Lambda é atualizada. A atualização da função Lambda aciona uma implantação CodeDeploy que transfere incrementalmente o tráfego de produção da versão original da função Lambda para a versão atualizada. 

**nota**  
Este tutorial requer que você crie recursos que podem resultar em cobranças na sua conta da AWS . Isso inclui possíveis cobranças para CodeDeploy CloudWatch, Amazon AWS Lambda e. Para obter mais informações, consulte [CodeDeploy preços](https://aws.amazon.com/codedeploy/pricing/), [ CloudWatch preços da Amazon](https://aws.amazon.com/cloudwatch/pricing/) e [AWS Lambda preços](https://aws.amazon.com/lambda/pricing/).

**Topics**
+ [Pré-requisitos](tutorial-lambda-sam-prereqs.md)
+ [Etapa 1: Configurar sua infraestrutura](tutorial-lambda-sam-setup-infrastructure.md)
+ [Etapa 2: Atualizar a função do Lambda](tutorial-lambda-sam-update-function.md)
+ [Etapa 3: Implantar a função do Lambda atualizada](tutorial-lambda-sam-deploy-update.md)
+ [Etapa 4: Visualizar os resultados da implantação](tutorial-lambda-sam-deploy-view-results.md)
+ [Etapa 5: limpar](tutorial-lambda-clean-up.md)

# Pré-requisitos
<a name="tutorial-lambda-sam-prereqs"></a>

Para concluir este tutorial, você deve primeiramente:
+  Siga as etapas em [Começando com CodeDeploy](getting-started-codedeploy.md). 
+  Instale a AWS Serverless Application Model CLI. Para obter informações, consulte [Instalar a CLI do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). 
+  Crie um bucket S3. AWS O SAM carrega os artefatos que são referenciados em seu [modelo de AWS SAM](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/tutorial-lambda-sam-template.html) nesse bucket. 

# Etapa 1: Configurar sua infraestrutura
<a name="tutorial-lambda-sam-setup-infrastructure"></a>

 Este tópico mostra como usar para criar arquivos AWS SAM para seu AWS SAM modelo e suas funções do Lambda. Em seguida, você usa os `deploy` comandos AWS SAM `package` e para gerar os componentes em sua infraestrutura. Quando sua infraestrutura estiver pronta, você terá um grupo de CodeDeploy aplicativos e implantação, a função Lambda para atualizar e implantar e duas funções Lambda que contêm testes de validação que são executados quando você implanta a função Lambda. Quando concluído, você pode usar CloudFormation para visualizar seus componentes no console Lambda ou AWS CLI para testar sua função Lambda. 

**Topics**
+ [Criar seus arquivos](tutorial-lambda-create-files.md)
+ [Package o aplicativo AWS SAM](tutorial-lambda-sam-package.md)
+ [Implantar o aplicativo AWS SAM](tutorial-lambda-sam-deploy.md)
+ [(Opcional) Inspecionar e testar sua infraestrutura](tutorial-lambda-sam-confirm-components.md)

# Criar seus arquivos
<a name="tutorial-lambda-create-files"></a>

 Para criar sua infraestrutura, você deve criar os seguintes arquivos: 
+ `template.yml`
+ `myDateTimeFunction.js`
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`

**Topics**
+ [Crie seu modelo de AWS SAM](tutorial-lambda-sam-template.md)
+ [Criar um arquivo para sua função do Lambda](tutorial-lambda-sam-create-lambda-function.md)
+ [Crie um arquivo para sua função BeforeAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-before-traffic.md)
+ [Crie um arquivo para sua função AfterAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-after-traffic.md)

# Crie seu modelo de AWS SAM
<a name="tutorial-lambda-sam-template"></a>

Crie um arquivo de modelo do AWS SAM que especifique os componentes em sua infraestrutura.

**Para criar seu modelo de AWS SAM**

1.  Crie um diretório denominado `SAM-Tutorial`. 

1.  No diretório `SAM-Tutorial`, crie um arquivo chamado `template.yml`. 

1.  Copie o código YAML a seguir no `template.yml`. Este é seu modelo do AWS SAM . 

   ```
   AWSTemplateFormatVersion : '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: A sample SAM template for deploying Lambda functions.
   
   Resources:
   # Details about the myDateTimeFunction Lambda function
     myDateTimeFunction:
       Type: AWS::Serverless::Function
       Properties:
         Handler: myDateTimeFunction.handler
         Runtime: nodejs18.x
   # Instructs your myDateTimeFunction is published to an alias named "live".      
         AutoPublishAlias: live
   # Grants this function permission to call lambda:InvokeFunction
         Policies:
           - Version: "2012-10-17"		 	 	 
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: '*'
         DeploymentPreference:
   # Specifies the deployment configuration      
             Type: Linear10PercentEvery1Minute
   # Specifies Lambda functions for deployment lifecycle hooks
             Hooks:
               PreTraffic: !Ref beforeAllowTraffic
               PostTraffic: !Ref afterAllowTraffic
               
   # Specifies the BeforeAllowTraffic lifecycle hook Lambda function
     beforeAllowTraffic:
       Type: AWS::Serverless::Function
       Properties:
         Handler: beforeAllowTraffic.handler
         Policies:
           - Version: "2012-10-17"		 	 	 
   # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus        
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "codedeploy:PutLifecycleEventHookExecutionStatus"
               Resource:
                 !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
           - Version: "2012-10-17"		 	 	 
   # Grants this function permission to call lambda:InvokeFunction        
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: !Ref myDateTimeFunction.Version
         Runtime: nodejs18.x
   # Specifies the name of the Lambda hook function      
         FunctionName: 'CodeDeployHook_beforeAllowTraffic'
         DeploymentPreference:
           Enabled: false
         Timeout: 5
         Environment:
           Variables:
             NewVersion: !Ref myDateTimeFunction.Version
             
   # Specifies the AfterAllowTraffic lifecycle hook Lambda function
     afterAllowTraffic:
       Type: AWS::Serverless::Function
       Properties:
         Handler: afterAllowTraffic.handler
         Policies:
           - Version: "2012-10-17"		 	 	 
             Statement: 
   # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus         
             - Effect: "Allow"
               Action: 
                 - "codedeploy:PutLifecycleEventHookExecutionStatus"
               Resource:
                 !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
           - Version: "2012-10-17"		 	 	 
             Statement: 
   # Grants this function permission to call lambda:InvokeFunction          
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: !Ref myDateTimeFunction.Version
         Runtime: nodejs18.x
   # Specifies the name of the Lambda hook function      
         FunctionName: 'CodeDeployHook_afterAllowTraffic'
         DeploymentPreference:
           Enabled: false
         Timeout: 5
         Environment:
           Variables:
             NewVersion: !Ref myDateTimeFunction.Version
   ```

Esse modelo especifica o seguinte. Para obter mais informações, consulte [Conceitos de modelo do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html).

**Uma função do Lambda chamada `myDateTimeFunction`**  
 Quando essa função do Lambda é publicada, a linha `AutoPublishAlias` no modelo a vincula a um alias chamado `live`. Posteriormente neste tutorial, uma atualização dessa função aciona uma implantação AWS CodeDeploy que transfere incrementalmente o tráfego de produção da versão original para a versão atualizada. 

**Duas funções de validação de implantação do Lambda**  
 As seguintes funções do Lambda são executadas durante os ganchos do ciclo de CodeDeploy vida. As funções contêm código que validam a implantação da `myDateTimeFunction` atualizada. O resultado dos testes de validação é passado para o CodeDeploy usando seu método da API `PutLifecycleEventHookExecutionStatus`. Se houver falha em um teste de validação, haverá falha na implantação e ela será revertida.   
+  `CodeDeployHook_beforeAllowTraffic` é executado durante o gancho `BeforeAllowTraffic`. 
+  `CodeDeployHook_afterAllowTraffic` é executado durante o gancho `AfterAllowTraffic`. 
O nome das duas funções começa com `CodeDeployHook_`. A função `CodeDeployRoleForLambda` permite chamadas para o método `invoke` do Lambda somente em funções do Lambda com nomes que começam com esse prefixo. Para obter mais informações, consulte [AppSpec seção 'hooks' para uma implantação do AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda) e [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html) na *Referência da API do CodeDeploy *. 

**Detecção automática de uma função do Lambda atualizada**  
 O termo `AutoPublishAlias` informa à estrutura para detectar quando a função `myDateTimeFunction` muda e implanta-a usando o alias `live`. 

**Uma configuração de implantação**  
 A configuração de implantação determina a taxa na qual seu CodeDeploy aplicativo transfere o tráfego da versão original da função Lambda para a nova versão. Esse modelo especifica a configuração de implantação predefinida `Linear10PercentEvery1Minute`.   
 Você não pode especificar uma configuração de implantação personalizada em um modelo do AWS SAM. Para obter mais informações, consulte [Crie uma configuração de implantação com CodeDeploy](deployment-configurations-create.md).

**Funções de gancho de ciclo de vida de implantação**  
 A seção `Hooks` especifica as funções a serem executadas durante ganchos de evento de ciclo de vida. `PreTraffic` especifica a função que é executada durante o gancho `BeforeAllowTraffic`. `PostTraffic` especifica a função que é executada durante o gancho `AfterAllowTraffic`. 

**Permissões para o Lambda invocar outra função do Lambda**  
 A `lambda:InvokeFunction` permissão especificada concede à função usada pelo aplicativo AWS SAM permissão para invocar uma função Lambda. Isso é necessário quando as funções `CodeDeployHook_beforeAllowTraffic` e `CodeDeployHook_afterAllowTraffic` invocam a função do Lambda implantada durante os testes de validação. 

# Criar um arquivo para sua função do Lambda
<a name="tutorial-lambda-sam-create-lambda-function"></a>

Crie o arquivo para a função que você atualiza e implanta posteriormente neste tutorial.

**nota**  
 Uma função do Lambda pode usar qualquer runtime compatível com o AWS Lambda. Para obter mais informações, consulte [Tempos de execução do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). 

**Como criar sua função do Lambda**

1.  Crie um arquivo de texto e salve-o como `myDateTimeFunction.js` no diretório `SAM-Tutorial`. 

1.  Copie o código Node.js a seguir no `myDateTimeFunction.js`. 

   

   ```
   'use strict';
       
       exports.handler = function(event, context, callback) {
       
         if (event.body) {
           event = JSON.parse(event.body);
         }
       
         var sc; // Status code
         var result = ""; // Response payload
       
         switch(event.option) {
           case "date": 
             switch(event.period) {
               case "yesterday":
                 result = setDateResult("yesterday");
                 sc = 200;
                 break;
               case "today":
                 result = setDateResult();
                 sc = 200;
                 break;
               case "tomorrow":
                 result = setDateResult("tomorrow");
                 sc = 200;
                 break;
               default:
                 result = {
                   "error": "Must specify 'yesterday', 'today', or 'tomorrow'."
                 };
                 sc = 400;
                 break;
             }
             break;
             
       /*      Later in this tutorial, you update this function by uncommenting 
               this section. The framework created by AWS SAM detects the update 
               and triggers a deployment by CodeDeploy. The deployment shifts 
               production traffic to the updated version of this function.
               
               case "time":
               var d = new Date();
               var h = d.getHours();
               var mi = d.getMinutes();
               var s = d.getSeconds();
       
               result = {
                 "hour": h,
                 "minute": mi,
                 "second": s
               };
               sc = 200;
               break;
       */
             default:
               result = {
                 "error": "Must specify 'date' or 'time'."
               };
               sc = 400;
             break;
         }
       
         const response = {
           statusCode: sc,
           headers: { "Content-type": "application/json" },
           body: JSON.stringify( result )
         };
       
         callback(null, response);
       
         function setDateResult(option) {
       
           var d = new Date(); // Today
           var mo; // Month
           var da; // Day
           var y; // Year
       
           switch(option) {
             case "yesterday":
               d.setDate(d.getDate() - 1);
               break;
             case "tomorrow":
               d.setDate(d.getDate() + 1);
             default:
              break;
           }
       
           mo = d.getMonth() + 1; // Months are zero offset (0-11)
           da = d.getDate();
           y = d.getFullYear();
       
           result = {
             "month": mo,
             "day": da,
             "year": y
           };
       
           return result;
         }
       };
   ```

A função do Lambda retorna o dia, mês e ano de ontem, hoje ou amanhã. Posteriormente neste tutorial, elimine o comentário do código que atualiza a função para retornar informações sobre o dia ou a hora que você especificar (por exemplo, o dia, mês e ano, ou a hora, o minuto e o segundo atuais). A estrutura criada por AWS SAM detecta e implanta a versão atualizada da função. 

**nota**  
 Essa função Lambda também é usada em um AWS Cloud9 tutorial. AWS Cloud9 é um ambiente de desenvolvimento integrado baseado em nuvem. Para obter informações sobre como criar, executar, atualizar e depurar essa função em AWS Cloud9, consulte o [AWS Lambda tutorial para AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial-lambda.html). 

# Crie um arquivo para sua função BeforeAllowTraffic Lambda
<a name="tutorial-lambda-sam-create-lambda-before-traffic"></a>

Crie o arquivo para sua função do Lambda de hook `beforeAllowTraffic`.

1.  Crie um arquivo de texto e salve-o como `beforeAllowTraffic.js` no diretório `SAM-Tutorial`. 

1.  Copie o código Node.js a seguir no `beforeAllowTraffic.js`. Essa função é executada durante o gancho `BeforeAllowTraffic` de sua implantação. 

   ```
   'use strict';
       
       const AWS = require('aws-sdk'); 
       const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
       var lambda = new AWS.Lambda();
       
       exports.handler = (event, context, callback) => {
       
       	console.log("Entering PreTraffic Hook!");
       	
       	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
         var deploymentId = event.DeploymentId;
       	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
       
       	var functionToTest = process.env.NewVersion;
       	console.log("BeforeAllowTraffic hook tests started");
       	console.log("Testing new function version: " + functionToTest);
       
       	// Create parameters to pass to the updated Lambda function that
       	// include the newly added "time" option. If the function did not
       	// update, then the "time" option is invalid and function returns
       	// a statusCode of 400 indicating it failed.
       	var lambdaParams = {
       		FunctionName: functionToTest,    
       		Payload: "{\"option\": \"time\"}", 
       		InvocationType: "RequestResponse"
       	};
       
       	var lambdaResult = "Failed";
       	// Invoke the updated Lambda function.
       	lambda.invoke(lambdaParams, function(err, data) {
       		if (err){	// an error occurred
       			console.log(err, err.stack);
       			lambdaResult = "Failed";
       		}
       		else{	// successful response
       			var result = JSON.parse(data.Payload);
       			console.log("Result: " +  JSON.stringify(result));
             console.log("statusCode: " + result.statusCode);
             
             // Check if the status code returned by the updated
             // function is 400. If it is, then it failed. If 
             // is not, then it succeeded.
       			if (result.statusCode != "400"){
               console.log("Validation succeeded");
       				lambdaResult = "Succeeded";
             }
             else {
               console.log("Validation failed");
             }
       
       			// Complete the PreTraffic Hook by sending CodeDeploy the validation status
       			var params = {
       				deploymentId: deploymentId,
       				lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
       				status: lambdaResult // status can be 'Succeeded' or 'Failed'
       			};
       			
       			// Pass CodeDeploy the prepared validation test results.
       			codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
       				if (err) {
       					// Validation failed.
       					console.log("CodeDeploy Status update failed");
       					console.log(err, err.stack);
       					callback("CodeDeploy Status update failed");
       				} else {
       					// Validation succeeded.
       					console.log("CodeDeploy status updated successfully");
       					callback(null, "CodeDeploy status updated successfully");
       				}
       			});
       		}  
       	});
       }
   ```

# Crie um arquivo para sua função AfterAllowTraffic Lambda
<a name="tutorial-lambda-sam-create-lambda-after-traffic"></a>

Crie o arquivo para sua função do Lambda de hook `afterAllowTraffic`.

1.  Crie um arquivo de texto e salve-o como `afterAllowTraffic.js` no diretório `SAM-Tutorial`. 

1.  Copie o código Node.js a seguir no `afterAllowTraffic.js`. Essa função é executada durante o gancho `AfterAllowTraffic` de sua implantação. 

   ```
   'use strict';
       
       const AWS = require('aws-sdk');
       const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
       var lambda = new AWS.Lambda();
       
       exports.handler = (event, context, callback) => {
       
       	console.log("Entering PostTraffic Hook!");
       	
       	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
         var deploymentId = event.DeploymentId;
       	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
       
       	var functionToTest = process.env.NewVersion;
       	console.log("AfterAllowTraffic hook tests started");
       	console.log("Testing new function version: " + functionToTest);
       
       	// Create parameters to pass to the updated Lambda function that
       	// include the original "date" parameter. If the function did not 
       	// update as expected, then the "date" option might be invalid. If 
       	// the parameter is invalid, the function returns
       	// a statusCode of 400 indicating it failed.
       	var lambdaParams = {
       		FunctionName: functionToTest,    
       		Payload: "{\"option\": \"date\", \"period\": \"today\"}", 
       		InvocationType: "RequestResponse"
       	};
       
       	var lambdaResult = "Failed";
       	// Invoke the updated Lambda function.
       	lambda.invoke(lambdaParams, function(err, data) {
       		if (err){	// an error occurred
       			console.log(err, err.stack);
       			lambdaResult = "Failed";
       		}
       		else{	// successful response
       			var result = JSON.parse(data.Payload);
       			console.log("Result: " +  JSON.stringify(result));
             console.log("statusCode: " + result.statusCode);
             
             // Check if the status code returned by the updated
             // function is 400. If it is, then it failed. If 
             // is not, then it succeeded.
       			if (result.statusCode != "400"){
               console.log("Validation of time parameter succeeded");
       				lambdaResult = "Succeeded";
             }
             else {
               console.log("Validation failed");
             }
       
       			// Complete the PostTraffic Hook by sending CodeDeploy the validation status
       			var params = {
       				deploymentId: deploymentId,
       				lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
       				status: lambdaResult // status can be 'Succeeded' or 'Failed'
       			};
       			
       			// Pass CodeDeploy the prepared validation test results.
       			codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
       				if (err) {
       					// Validation failed.
       					console.log("CodeDeploy Status update failed");
       					console.log(err, err.stack);
       					callback("CodeDeploy Status update failed");
       				} else {
       					// Validation succeeded.
       					console.log("CodeDeploy status updated successfully");
       					callback(null, "CodeDeploy status updated successfully");
       				}
       			});
       		}  
       	});
       }
   ```

# Package o aplicativo AWS SAM
<a name="tutorial-lambda-sam-package"></a>

 Agora você deve ter quatro arquivos em seu diretório `SAM-Tutorial`: 
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`
+ `myDateTimeFunction.js`
+ `template.yml`

 Agora você está pronto para usar o **sam package** comando AWS SAM para criar e empacotar artefatos para suas funções CodeDeploy e aplicativos Lambda. Os artefatos são carregados em um bucket do S3. A saída do comando é um novo arquivo chamado `package.yml`. Esse arquivo é usado pelo **sam deploy** comando AWS SAM na próxima etapa. 

**nota**  
 Para obter mais informações sobre o comando **sam package**, consulte a [Referência do comando da CLI AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) no *Guia do desenvolvedor do AWS Serverless Application Model *. 

 No diretório `SAM-Tutorial`, execute o seguinte: 

```
sam package \
  --template-file template.yml \
  --output-template-file package.yml \
  --s3-bucket amzn-s3-demo-bucket
```

Para o parâmetro `s3-bucket`, especifique o bucket do Amazon S3 que você criou como um pré-requisito para este tutorial. `output-template-file`Especifica o nome do novo arquivo usado pelo **sam deploy** comando AWS SAM.

# Implantar o aplicativo AWS SAM
<a name="tutorial-lambda-sam-deploy"></a>

 Use o **sam deploy** comando AWS SAM com o `package.yml` arquivo para criar suas funções Lambda e seu grupo de CodeDeploy aplicativos e implantação usando. CloudFormation

**nota**  
Para obter mais informações sobre o comando **sam deploy**, consulte a [Referência do comando da CLI AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) no *Guia do desenvolvedor do AWS Serverless Application Model *. 

 No diretório `SAM-Tutorial`, execute o comando a seguir. 

```
sam deploy \
  --template-file package.yml \
  --stack-name my-date-time-app \
  --capabilities CAPABILITY_IAM
```

 O parâmetro `--capabilities CAPABILITY_IAM` é necessário para autorizar o CloudFormation a criar perfis do IAM. 

# (Opcional) Inspecionar e testar sua infraestrutura
<a name="tutorial-lambda-sam-confirm-components"></a>

 Este tópico mostra como visualizar seus componentes de infraestrutura e testar sua função do Lambda. 

**Como ver o resultado da pilha depois de executar o `sam deploy`**

1. Abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1.  No painel de navegação, escolha **Pilhas**. A pilha `my-date-time-app` é exibida na parte superior. 

1.  Escolha a guia **Events (Eventos)** para ver quais eventos foram concluídos. É possível visualizar os eventos enquanto a criação da pilha está em andamento. Quando a criação da pilha for concluída, você poderá ver todos os eventos de criação da pilha. 

1.  Com a pilha selecionada, escolha **Resources (Recursos)**. Na coluna **Tipo**, é possível ver suas funções do Lambda, `myDateTimeFunction`, `CodeDeployHook_beforeAllowTraffic`, e `CodeDeployHook_afterAllowTraffic`. A coluna **ID físico** de cada uma de suas funções do Lambda contém um link para visualizar as funções no console do Lambda. 
**nota**  
 O nome da função `myDateTimeFunction` Lambda é prefixado com o nome da CloudFormation pilha e tem um identificador adicionado a ele, então parece. `my-date-time-app-myDateTimeFunction-123456ABCDEF` 

1. Abra o CodeDeploy console em [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).

1.  No painel de navegação, expanda a opção **Deploy (Implantar)** e escolha **Applications (Aplicativos)**. 

1.  Você deve ver um novo CodeDeploy aplicativo criado por CloudFormation com um nome que começa com`my-date-time-app-ServerlessDeploymentApplication`. Escolha esse aplicativo. 

1.  Você deverá ver um grupo de implantação com um nome que começa com `my-date-time-app-myDateTimeFunctionDeploymentGroup`. Escolha esse grupo de implantação. 

    Em **Configuração de implantação**, você deve ver **CodeDeployDefault. LambdaLinear10 PercentEvery 1 minuto**. 

**(Opcional) Como testar sua função (console)**

1. Abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  No painel de navegação, escolha sua função `my-date-time-app-myDateTimeFunction`. No console, o nome dela contém um identificador, portanto, ele se parece com `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Escolha **Testar**. 

1.  Em **Event name (Nome do evento)**, insira um nome para o evento de teste. 

1.  Insira o seguinte para o evento de teste e escolha **Create (Criar)**. 

   ```
   {
     "option": "date",
     "period": "today"
   }
   ```

1.  Escolha **Testar**. Você deverá ver apenas o evento de teste na lista de eventos de teste. 

    Em **Execution result (Resultado da execução)**, você deverá ver **succeeded (bem-sucedido)**. 

1.  Em **Execution result (Resultado da execução)**, expanda **Details (Detalhes)** para ver os resultados. Você deverá ver o mês, dia e ano atuais. 

**(Opcional) Como testar sua função (AWS CLI)**

1.  Localize o ARN de sua função do Lambda. Ele será exibido na parte superior do console do Lambda quando você estiver visualizando a função. 

1.  Execute o comando a seguir. *your-function-arn*Substitua pela função ARN. 

   ```
   aws lambda invoke \
   --function your-function-arn \
   --cli-binary-format raw-in-base64-out \
   --payload "{\"option\": \"date\", \"period\": \"today\"}" out.txt
   ```

1.  Abra `out.txt` para confirmar que o resultado contém o mês, dia e ano atuais. 

# Etapa 2: Atualizar a função do Lambda
<a name="tutorial-lambda-sam-update-function"></a>

 Neste tópico, você atualiza o arquivo `myDateTimeFunction.js`. Na próxima etapa, você usará o arquivo para implantar a função atualizada. Isso CodeDeploy aciona a implantação transferindo o tráfego de produção da versão atual da função Lambda para a versão atualizada. 

**Como atualizar sua função do Lambda**

1.  Abra o `myDateTimeFunction.js`. 

1.  Remova os dois marcadores de comentário ("`/*`" e "`*/`") e o texto explicativo no início e no final do `case` chamado `time` no bloco `switch`. 

    O código sem comentário permite que você passe um novo parâmetro, `time`, para a função. Se você passar `time` para a função atualizada, ela retornará a `hour`, o `minute` e o `second` atuais. 

1.  Salvar `myDateTimeFunction.js`. Ele deve ter a seguinte aparência: 

   ```
   'use strict';
   
   exports.handler = function(event, context, callback) {
   
     if (event.body) {
       event = JSON.parse(event.body);
     }
   
     var sc; // Status code
     var result = ""; // Response payload
   
     switch(event.option) {
       case "date":
         switch(event.period) {
           case "yesterday":
             result = setDateResult("yesterday");
             sc = 200;
             break;
           case "today":
             result = setDateResult();
             sc = 200;
             break;
           case "tomorrow":
             result = setDateResult("tomorrow");
             sc = 200;
             break;
           default:
             result = {
               "error": "Must specify 'yesterday', 'today', or 'tomorrow'."
             };
             sc = 400;
             break;
         }
         break;
         case "time":
           var d = new Date();
           var h = d.getHours();
           var mi = d.getMinutes();
           var s = d.getSeconds();
   
           result = {
             "hour": h,
             "minute": mi,
             "second": s
           };
           sc = 200;
           break;
   
         default:
           result = {
             "error": "Must specify 'date' or 'time'."
           };
           sc = 400;
         break;
     }
   
     const response = {
       statusCode: sc,
       headers: { "Content-type": "application/json" },
       body: JSON.stringify( result )
     };
   
     callback(null, response);
   
     function setDateResult(option) {
   
       var d = new Date(); // Today
       var mo; // Month
       var da; // Day
       var y; // Year
   
       switch(option) {
         case "yesterday":
           d.setDate(d.getDate() - 1);
           break;
         case "tomorrow":
           d.setDate(d.getDate() + 1);
         default:
          break;
       }
   
       mo = d.getMonth() + 1; // Months are zero offset (0-11)
       da = d.getDate();
       y = d.getFullYear();
   
       result = {
         "month": mo,
         "day": da,
         "year": y
       };
   
       return result;
     }
   };
   ```

# Etapa 3: Implantar a função do Lambda atualizada
<a name="tutorial-lambda-sam-deploy-update"></a>

 Nesta etapa, você usa a `myDateTimeFunction.js` atualizada para atualizar e iniciar a implantação da função do Lambda. Você pode monitorar o progresso da implantação no AWS Lambda console CodeDeploy ou. 

 A `AutoPublishAlias: live` linha em seu AWS SAM modelo faz com que sua infraestrutura detecte atualizações em funções que usam o `live` alias. Uma atualização em sua função aciona uma implantação CodeDeploy que transfere o tráfego de produção da versão original da função para a versão atualizada. 

 Os comandos **sam package** e **sam deploy** são usados para atualizar e acionar a implantação de sua função do Lambda. Você executou esses comandos em [Package o aplicativo AWS SAM](tutorial-lambda-sam-package.md) e [Implantar o aplicativo AWS SAM](tutorial-lambda-sam-deploy.md). 

**Como implantar sua função do Lambda atualizada**

1.  No diretório `SAM-Tutorial`, execute o comando a seguir. 

   ```
   sam package \
     --template-file template.yml \
     --output-template-file package.yml  \
     --s3-bucket amzn-s3-demo-bucket
   ```

    Isso cria um novo conjunto de artefatos que fazem referência à função do Lambda atualizada no bucket do S3. 

1.  No diretório `SAM-Tutorial`, execute o comando a seguir. 

   ```
   sam deploy \
     --template-file package.yml \
     --stack-name my-date-time-app \
     --capabilities CAPABILITY_IAM
   ```

   Como o nome da pilha ainda é`my-date-time-app`, CloudFormation reconhece que essa é uma atualização da pilha. **Para ver sua pilha atualizada, retorne ao CloudFormation console e, no painel de navegação, escolha Pilhas.**

**(Opcional) para visualizar o tráfego durante uma implantação (CodeDeploy console)**

1. Abra o CodeDeploy console em [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).

1.  No painel de navegação, expanda **Aplicativos** e escolha seu **my-date-time-app- ServerlessDeploymentApplication** aplicativo. 

1.  Em **Deployment groups (Grupos de implantação)**, escolha o grupo de implantação do aplicativo. Seu status deve ser **In progress (Em andamento**). 

1.  Em **Deployment group history (Histórico de grupos de implantação)**, escolha a implantação que está em andamento. 

   A barra de progresso de **Traffic shifting (Deslocamento de tráfego)** e as porcentagens nas caixas **Original** e **Replacement (Substituição)** nesta página exibem o progresso.   
![\[A seção de progresso da mudança de tráfego do CodeDeploy console.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/lambda-tutorial-codedeploy-console-20-percent-deployed.png)

**(Opcional) Como visualizar o tráfego durante uma implantação (console do Lambda)**

1. Abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  No painel de navegação, escolha sua função `my-date-time-app-myDateTimeFunction`. No console, o nome dela contém um identificador, portanto, ele se parece com `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Escolha **Aliases** e, em seguida, escolha **ao vivo**. 

Os pesos ao lado da versão original da função (versão 1) e da versão atualizada da função (versão 2) mostram quanto tráfego é distribuído para cada versão no momento em que a página do console do AWS Lambda foi carregada. A página não atualiza os pesos ao longo do tempo. Se você atualizar a página uma vez por minuto, o peso da versão 1 diminuirá em 10% e o peso da versão 2 aumentará em 10% até que o peso da versão 2 seja 100. 

![\[A seção de aliases do CodeDeploy console.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/lambda-tutorial-lambda-console-20-percent-deployed.png)


# Etapa 4: Visualizar os resultados da implantação
<a name="tutorial-lambda-sam-deploy-view-results"></a>

Nesta etapa, você visualiza os resultados da implantação. Se a implantação for bem-sucedida, você poderá confirmar que a função do Lambda atualizada recebe o tráfego de produção. Se sua implantação falhar, você poderá usar o CloudWatch Logs para visualizar a saída dos testes de validação na função Lambda que são executados durante os ganchos do ciclo de vida da implantação. 

**Topics**
+ [Testar a função implantada](#tutorial-lambda-sam-deploy-test-deployed-function)
+ [Exibir eventos de gancho em CloudWatch Logs](#tutorial-lambda-view-hook-events)

## Testar a função implantada
<a name="tutorial-lambda-sam-deploy-test-deployed-function"></a>

 O comando **sam deploy** atualiza a função do Lambda do `my-date-time-app-myDateTimeFunction`. A versão da função é atualizada para 2 e adicionada ao alias `live`. 

**Como ver a atualização no console do Lambda**

1. Abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  No painel de navegação, escolha a função `my-date-time-app-myDateTimeFunction`. No console, o nome dela contém um identificador, portanto, ele se parece com `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Escolha **Qualifiers (Qualificadores)** e **Aliases**. Depois que a implantação for concluída (aproximadamente 10 minutos), no alias `live`, você deverá ver **Version: 2 (Versão: 2)**.  
![\[A seção de aliases do CodeDeploy console.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/lambda-tutorial-function-version.png)

1.  Em **Function code (Código da função)**, visualize o código-fonte da função. Suas alterações deverão ser exibidas. 

1.  (Opcional) Você pode usar as instruções de teste em [Etapa 2: Atualizar a função do Lambda](tutorial-lambda-sam-update-function.md) para testar sua função atualizada. Crie um novo evento de teste com a carga a seguir e confirme se o resultado contém a hora, o minuto e o segundo atuais. 

   ```
   {
       "option": "time"
     }
   ```

    Para usar o AWS CLI para testar sua função atualizada, execute o comando a seguir e abra `out.txt` para confirmar se o resultado contém a hora, o minuto e o segundo atuais. 

   ```
   aws lambda invoke --function your-function-arn --payload "{\"option\": \"time\"}" out.txt 
   ```
**nota**  
 Se você usar o AWS CLI para testar sua função antes da conclusão da implantação, poderá receber resultados inesperados. Isso ocorre porque transfere CodeDeploy gradualmente 10% do tráfego para a versão atualizada a cada minuto. Durante a implantação, algum tráfego ainda aponta para a versão original, portanto, o `aws lambda invoke` pode usar a versão original. Após 10 minutos, a implantação é concluída e todo o tráfego aponta para a nova versão da função. 

## Exibir eventos de gancho em CloudWatch Logs
<a name="tutorial-lambda-view-hook-events"></a>

 Durante o `BeforeAllowTraffic` hook, CodeDeploy executa sua função `CodeDeployHook_beforeAllowTraffic` Lambda. Durante o `AfterAllowTraffic` hook, CodeDeploy executa sua função `CodeDeployHook_afterAllowTraffic` Lambda. Cada função executa um teste de validação que invoca a versão atualizada de sua função usando o novo parâmetro `time`. Se a atualização da função do Lambda for bem-sucedida, a opção `time` não causará um erro e a validação será bem-sucedida. Se a função não tiver sido atualizada, o parâmetro não reconhecido causará um erro e haverá falha na validação. Esses testes de validação são apenas para fins de demonstração. Escreva seus próprios testes para validar sua implantação. Você pode usar o console de CloudWatch registros para ver seus testes de validação. 

**Para ver seus eventos de CodeDeploy gancho**

1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Na página de navegação, escolha **Logs**. 

1.  Na lista de grupos de registros, escolha**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic** ou**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**. 

1.  Escolha o fluxo de logs. Você deverá ver somente um. 

1.  Expanda os eventos para ver seus detalhes.   
![\[O fluxo de registros de um grupo de CodeDeployHook registros.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/lambda-tutorial-cloudwatch.png)

# Etapa 5: limpar
<a name="tutorial-lambda-clean-up"></a>

Para evitar cobranças adicionais pelos recursos que você usou durante este tutorial, exclua os recursos criados pelo seu AWS SAM modelo e CloudWatch os registros criados pelas suas funções de validação do Lambda.

**Para excluir sua CloudFormation pilha**

1. Faça login no Console de gerenciamento da AWS e abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Na coluna **Stacks (Pilhas)** escolha sua pilha `my-date-time-app` e escolha **Delete (Excluir)**.

1. Quando solicitado, escolha **Excluir pilha**. As funções do Lambda, o grupo de CodeDeploy aplicativos e de implantação e as funções do IAM criadas por AWS SAM são excluídas.

**Para excluir seus registros em CloudWatch Registros**

1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Na página de navegação, escolha **Logs**. 

1.  Na lista de grupos de registros, escolha o botão ao lado de**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic**. 

1.  Em **Ações**, escolha **Excluir grupo de logs** e **Sim, Excluir**. 

1.  Na lista de grupos de registros, escolha o botão ao lado de**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**. 

1.  Em **Ações**, escolha **Excluir grupo de logs** e **Sim, Excluir**.