Crie um fluxo de trabalho sem servidor
com o AWS Step Functions e o AWS Lambda
Neste tutorial, você aprenderá a usar o AWS Step Functions para projetar e executar um fluxo de trabalho sem servidor que coordena várias funções do AWS Lambda. O AWS Lambda é um serviço de computação que permite executar código sem provisionar ou gerenciar servidores.
No nosso exemplo, você é um desenvolvedor que recebeu uma solicitação: criar um aplicativo sem servidor para automatizar o processamento de tíquetes de suporte em um call center. Seria possível ter uma função do Lambda chamando outra, mas você acha que será complicado gerenciar todas essas conexões quando o aplicativo do call center se tornar mais sofisticado. Além disso, qualquer mudança no fluxo do aplicativo exigirá mudanças em vários lugares e você poderia terminar tendo que reescrever o mesmo código várias vezes.
Para solucionar esse desafio, você decide usar o AWS Step Functions. O Step Functions é um serviço de orquestração sem servidor que permite coordenar com facilidade várias funções do Lambda em fluxos de trabalho fáceis de depurar e de alterar. O Step Functions manterá as suas funções do Lambda livres de lógica adicional acionando e monitorando cada etapa do aplicativo para você.
Nos próximos 10 minutos, você criará uma máquina de estado do Step Functions para descrever o processo do call center atual, criará algumas funções do Lambda simples para simular as tarefas da equipe de suporte e passará dados entre cada função do Lambda para monitorar o andamento do caso de suporte. Em seguida, você realizará vários testes no fluxo de trabalho para observar como ele responde a diferentes entradas. Por fim, você excluirá os recursos da AWS que usou no tutorial.
Você usará o AWS Step Functions e o AWS Lambda neste tutorial. Esses serviços fazem parte do nível gratuito da AWS.
Este tutorial exige uma conta da AWS
Não há cobranças adicionais para o Step Functions nem para o Lambda. Os recursos criados neste tutorial estão qualificados para o nível gratuito.
Etapa 1. Crie uma máquina de estado e um fluxo de trabalho sem servidor
A primeira etapa é projetar um fluxo de trabalho que descreva como deseja que os tíquetes de suporte sejam processados no call center. Os fluxos de trabalho descrevem um processo como uma série de tarefas distintas que podem ser repetidas continuamente.
Você conversa com o gerente do call center para discutir as melhores práticas para o processamento dos casos de suporte. Usando os fluxos de trabalho visuais do Step Functions como referência intuitiva, vocês definem juntos o fluxo desejado.
Em seguida, você projetará seu fluxo de trabalho no AWS Step Functions. O fluxo de trabalho chamará uma função do AWS Lambda para criar um caso de suporte, invocará outra função para atribuir o caso a um representante do suporte para resolução e assim por diante. O fluxo também passará dados entre as funções do Lambda para monitorar o status do caso de suporte à medida que for processado.
a. Abra o console do AWS Step Functions. Selecione Author with code snippets (Criar com trechos de código). Na caixa de texto Name (Nome), digite CallCenterStateMachine.
(clique para aumentar)
b. Substitua o conteúdo da janela State machine definition (Definição de máquina de estado) pela definição abaixo de máquina de estado da Amazon States Language (ASL). A Amazon States Language é uma linguagem estruturada baseada em JSON usada para definir a máquina de estado.
Essa máquina usa uma série de estados Task para abrir, atribuir e trabalhar em casos de suporte. Em seguida, um estado Choice (Escolha) é usado para determinar se o caso pode ou não ser fechado. Em seguida, dois outros estados Task fecham ou escalam o caso de suporte, conforme apropriado.
{
"Comment": "A simple AWS Step Functions state machine that automates a call center support session.",
"StartAt": "Open Case",
"States": {
"Open Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"Next": "Assign Case"
},
"Assign Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"Next": "Work on Case"
},
"Work on Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"Next": "Is Case Resolved"
},
"Is Case Resolved": {
"Type" : "Choice",
"Choices": [
{
"Variable": "$.Status",
"NumericEquals": 1,
"Next": "Close Case"
},
{
"Variable": "$.Status",
"NumericEquals": 0,
"Next": "Escalate Case"
}
]
},
"Close Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"End": true
},
"Escalate Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"Next": "Fail"
},
"Fail": {
"Type": "Fail",
"Cause": "Engage Tier 2 Support." }
}
}
(clique para aumentar)
c. Clique no botão de atualizar para exibir a definição da máquina de estado da ASL como um fluxo de trabalho visual. No nosso cenário, você pode verificar facilmente se o processo foi descrito corretamente revisando o fluxo de trabalho visual com o gerente do call center.
d. Clique em Next (Próximo).
(clique para aumentar)
Etapa 2. Crie uma função do AWS Identity and Access Management (IAM)
O AWS IAM é um serviço da web que ajuda a controlar o acesso a recursos da AWS com segurança. Nesta etapa, você criará uma função do IAM que permitirá ao Step Functions acessar o Lambda.
a. Abra o Console de Gerenciamento da AWS em outra janela do navegador. Quando a tela carregar, digite IAM na barra de pesquisa e selecione IAM para abrir o console do serviço.
(clique para aumentar)
b. Clique em Roles (Funções) e em Create Role (Criar função).
(clique para aumentar)
c. Na tela Create Roles (Criar funções), deixe a opção AWS Service (Serviço da AWS) marcado, selecione Step Functions e clique em Next: Permissions (Próximo: Permissões). Na próxima tela, clique em Next: Review (Próximo: Revisar).
(clique para aumentar)
d. Digite o Role name (Nome da função) como step_functions_basic_execution e clique em Create role (Criar função). Na próxima tela, clique em Next: Review (Próximo: Revisar).
(clique para aumentar)
e. A função é criada e aparece na lista. Selecione o nome da função para visualizá-la.
(clique para aumentar)
f. Copie o ARN da função na próxima tela.
(clique para aumentar)
Etapa 3. Adicione a função do IAM à máquina de estado
A próxima etapa é adicionar o ARN da função do IAM que você criou na máquina de estado com o AWS Step Functions.
a. Selecione a guia do navegador com o console do Step Functions.
b. Cole o ARN que você copiou na caixa de texto do IAM role ARN (ARN da função do IAM).
c. Clique em Create State Machine (Criar máquina de estado).
(clique para aumentar)
Etapa 4. Crie funções do AWS Lambda
Agora que você criou a máquina de estado, poderá decidir como quer realizar o trabalho. É possível conectar a máquina de estado às funções do AWS Lambda e a outros microsserviços que já existem no seu ambiente, ou criar novos. Neste tutorial, você criará algumas funções do Lambda simples que simulem as várias etapas do processamento de chamadas, como a atribuição do caso a um representante do suporte ao cliente.
a. Clique em Services(Serviços), digite Lambda na caixa de texto de pesquisa e selecione Lambda para abrir o console do serviço.
(clique para aumentar)
b. Clique em Create function (Criar função).
(clique para aumentar)
c. Selecione Author from scratch (Criar do zero).
d. Configure a primeira função do Lambda com estas definições:
Name (Nome) – OpenCaseFunction.
Runtime (Tempo de execução) – Node.js 4.3.
Role (Função) – Criar função personalizada.
Uma nova janela do IAM é exibida.
e. Em Role name (Nome da função), mantenha a opção lambda_basic_execution selecionada e clique em Allow (Permitir).
Você voltará automaticamente para o console do Lambda.
f. Clique em Create function (Criar função).
(clique para aumentar)
g. Substitua o conteúdo da janela Function code (Código de função) pelo código a seguir e clique em Save (Salvar).
exports.handler = (event, context, callback) => {
// Create a support case using the input as the case ID, then return a confirmation message
var myCaseID = event.inputCaseID;
var myMessage = "Case " + myCaseID + ": opened...";
var result = {Case: myCaseID, Message: myMessage};
callback(null, result);
};
(clique para aumentar)
h. Na parte superior da página, clique em Functions (Funções).
(clique para aumentar)
i. Repita as etapas 4b a 4d para criar mais 4 funções do Lambda usando a função do IAM lambda_basic_execution que você criou na etapa 4c.
Defina AssignCaseFunction como:
exports.handler = (event, context, callback) => {
// Assign the support case and update the status message
var myCaseID = event.Case;
var myMessage = event.Message + "assigned...";
var result = {Case: myCaseID, Message: myMessage};
callback(null, result);
};Defina WorkOnCaseFunction como:
exports.handler = (event, context, callback) => {
// Generate a random number to determine whether the support case has been resolved, then return that value along with the updated message.
var min = 0;
var max = 1;
var myCaseStatus = Math.floor(Math.random() * (max - min + 1)) + min;
var myCaseID = event.Case;
var myMessage = event.Message;
if (myCaseStatus == 1) {
// Support case has been resolved
myMessage = myMessage + "resolved...";
} else if (myCaseStatus == 0) {
// Support case is still open
myMessage = myMessage + "unresolved...";
}
var result = {Case: myCaseID, Status : myCaseStatus, Message: myMessage};
callback(null, result);
};Defina CloseCaseFunction como:
exports.handler = (event, context, callback) => {
// Close the support case
var myCaseStatus = event.Status;
var myCaseID = event.Case;
var myMessage = event.Message + "closed.";
var result = {Case: myCaseID, Status : myCaseStatus, Message: myMessage};
callback(null, result);
};Defina EscalateCaseFunction como:
exports.handler = (event, context, callback) => {
// Escalate the support case
var myCaseID = event.Case;
var myCaseStatus = event.Status;
var myMessage = event.Message + "escalating.";
var result = {Case: myCaseID, Status : myCaseStatus, Message: myMessage};
callback(null, result);
};Ao concluir, você deverá ter 5 funções do Lambda.
(clique para aumentar)
Etapa 5. Preencha o fluxo de trabalho
A próxima etapa é preencher os estados de tarefa no fluxo de trabalho do Step Functions com as funções do Lambda que você acabou de criar.
a. Clique em Services (Serviços), digite Lambda na caixa de texto de pesquisa e selecione Lambda para abrir o console do serviço.
(clique para aumentar)
b. Na tela State machines (Máquinas de estado), selecione a máquina CallCenterStateMachine que criou e clique em Edit (Editar).
(clique para aumentar)
c. Na seção State machine definition (Definição da máquina de estado), encontre a linha abaixo do estado Open Case (Abrir caso) que começa com Resource (Recurso).
Substitua o ARN de exemplo pelo ARN da OpenCaseFunction.
Você pode clicar no ARN de exemplo para exibir a lista de funções do AWS Lambda na sua conta e selecionar uma delas.
(clique para aumentar)
d. Repita a etapa anterior para atualizar os ARNs da função do Lambda para os estados Task Assign Case (Atribuir caso), Work on Case (Trabalhar no caso), Close Case (Fechar caso) e Escalate Case (Escalar caso) na sua máquina de estado e, em seguida, clique em Save (Salvar).
(clique para aumentar)
Etapa 6. Execute o fluxo de trabalho
O seu fluxo de trabalho sem servidor agora está pronto para ser executado. Uma execução da máquina de estado é uma instância do fluxo de trabalho e ocorre sempre que uma máquina de estado do Step Functions é executada e realiza as suas tarefas. Cada máquina de estado do Step Functions pode realizar múltiplas execuções simultâneas que podem ser iniciadas usando o console do Step Functions (que você fará a seguir) ou usando os AWS SDKs, ações da API do Step Functions ou a CLI da AWS. As execuções recebem entrada JSON e produzem saídas JSON.
a. Clique em Start execution (Iniciar execução).
(clique para aumentar)
b. Uma caixa de diálogo New execution (Nova execução) é exibida. Para fornecer uma identificação ao caso de suporte, insira o conteúdo abaixo na caixa de diálogo New execution (Nova execução) da janela Input (Entrada) e clique em Start execution (Iniciar execução).
{
"inputCaseID": "001"
}
(clique para aumentar)
c. À medida que o fluxo de trabalho é executado, cada etapa mudará de cor no painel Visual workflow (Fluxo de trabalho visual). Aguarde alguns segundos para que a execução seja concluída. Em seguida, no painel Execution details (Detalhes da execução), clique em Input (Entrada) e Output (Saída) para ver as entradas e os resultados do seu fluxo de trabalho.
(clique para aumentar)
d. O Step Functions permite inspecionar cada etapa da execução do fluxo de trabalho, incluindo as entradas e saídas de cada estado. Clique em cada tarefa do fluxo de trabalho e expanda os campos Input (Entrada) e Output (Saída) em Step details (Detalhes da etapa). Você poderá ver que a identificação do caso inserida na máquina de estado é passada de uma etapa para a outra, e que as mensagens são atualizadas à medida que cada função do Lambda conclui seu trabalho.
(clique para aumentar)
e. Role para baixo até a seção Execution event history (Histórico de eventos de execução). Clique em cada etapa de execução para ver como o Step Functions chamou as funções do Lambda e passou dados entre as funções.
(clique para aumentar)
f. Dependendo da saída de WorkOnCaseFunction, o fluxo de trabalho pode ter terminado resolvendo o caso de suporte e fechando o tíquete, ou escalado o tíquete para o próximo nível de suporte. Você pode repetir a execução algumas vezes para observar as diferenças de comportamento. Esta imagem exibe uma execução do fluxo de trabalho onde o caso de suporte foi escalado, gerando uma saída do fluxo de trabalho com estado Fail (Falha).
Em uma situação real, você pode escolher continuar trabalhando no caso até que ele seja resolvido, em vez de retirá-lo do fluxo de trabalho com uma falha. Para isso, você pode remover o estado Fail (Falha) e editar a tarefa Escalate Case (Escalar caso) na máquina de estado para voltar para o estado Work On Case (Trabalhar no caso). Nenhuma outra alteração nas funções do Lambda será necessária. As funções criadas para este tutorial são somente exemplos para que possamos avançar para a próxima etapa.
(clique para aumentar)
Etapa 7. Encerre os recursos
Nesta etapa, você encerrará os recursos relacionados ao AWS Step Functions e ao AWS Lambda.
Importante: é recomendável encerrar os recursos que não estão em uso, pois isso reduz custos. Pode haver cobranças caso os recursos não sejam encerrados.
a. Na parte superior da janela do console do AWS Step Functions, clique em State machines (Máquinas de estado).
(clique para aumentar)
b. Na janela State machines (Máquinas de estado), selecione CallCenterStateMachine e clique em Delete (Excluir). Para confirmar que você deseja excluir a máquina de estado, clique em Delete state machine (Excluir a máquina de estado) na caixa de diálogo exibida. A máquina de estado será excluída em poucos minutos, depois que o Step Functions confirmar que todas as execuções de processos internos foram concluídas.
(clique para aumentar)
c. Em seguida, você excluirá as funções do Lambda. Clique em Services (Serviços) no menu do Console de Gerenciamento da AWS e selecione Lambda.
(clique para aumentar)
d. Na tela Functions (Funções), clique em cada uma das funções criadas para este tutorial, selecione Actions (Ações) e, em seguida, Delete (Excluir). Confirme a exclusão clicando novamente em Delete (Excluir).
(clique para aumentar)
e. Por último, você excluirá todas as funções do IAM. Clique em Services (Serviços) no menu do Console de Gerenciamento da AWS e selecione IAM.
(clique para aumentar)
f. Selecione as duas funções do IAM que você criou para este tutorial e clique em Delete role (Excluir função). Confirme a exclusão clicando em Yes, Delete (Sim, excluir) na caixa de diálogo.
Agora você pode fazer logout do Console de Gerenciamento da AWS.
(clique para aumentar)
Parabéns!
Bom trabalho! Você acabou de criar um fluxo de trabalho sem servidor usando o AWS Step Functions que aciona várias funções do AWS Lambda. O seu fluxo de trabalho coordenou todas as funções de acordo com a lógica definida e passou dados de um estado para outro, o que significa que você não precisou escrever o mesmo código para cada função individual.
Agora que você aprendeu a projetar e executar um fluxo de trabalho sem servidor, poderá avançar para o próximo tutorial, onde aprenderá a usar o Step Functions para processar erros da função do Lambda. Você criará uma máquina de estado com os campos Retry (Tentar novamente) e Catch (Detectar) correspondentes aos códigos de resposta de uma simulação de API baseada no tipo de mensagem de erro, um método chamado de processamento de erro de função.