Introdução ao Step Functions e Exemplo em Golang: Processando Pagamentos de Compras
Tags: aws, go, stepfunctions
Published: 2023-08-21 02:30:21

Se você está buscando uma maneira eficiente e escalável de coordenar fluxos de trabalho em suas aplicações, o AWS Step Functions é uma ferramenta poderosa a ser considerada. Neste post, vamos explorar o que é o Step Functions e como ele pode ser usado para gerenciar fluxos de trabalho complexos. Além disso, iremos apresentar um exemplo prático em Golang, demonstrando como você pode usar o Step Functions para validar um pagamento de uma compra.

## O que é o AWS Step Functions?

O AWS Step Functions é um serviço de orquestração de fluxos de trabalho que permite coordenar e gerenciar a execução de várias etapas e serviços em uma aplicação. Ele ajuda a simplificar processos complexos, automatizando a coordenação entre diferentes componentes do sistema e permitindo a construção de fluxos de trabalho visuais e de fácil manutenção.

As principais características do Step Functions incluem:

1. **Coordenação Simplificada**: O serviço permite definir fluxos de trabalho como máquinas de estado, onde cada etapa é uma função ou um serviço executado em resposta a um evento.

2. **Visibilidade**: O Step Functions oferece visibilidade completa sobre o status e o progresso de cada etapa do fluxo de trabalho, tornando a depuração e o monitoramento mais fáceis.

3. **Flexibilidade**: É possível adicionar, remover ou modificar etapas do fluxo de trabalho sem a necessidade de reescrever todo o código. Isso facilita a evolução e a adaptação da aplicação.

4. **Integração com AWS**: O serviço é integrado com outros serviços da AWS, permitindo que você coordene facilmente os recursos da nuvem em seus fluxos de trabalho.

## Exemplo : Validação de Pagamento
Imagine que você está construindo uma aplicação de comércio eletrônico e deseja automatizar o processo de pagamento. Vamos criar um exemplo em Golang usando o Step Functions para ilustrar como isso pode ser feito.

## Definindo o Fluxo de Trabalho:
Primeiro, você define o fluxo de trabalho como uma máquina de estados. No AWS Step Functions, isso é feito através da definição do JSON que descreve as etapas do fluxo. Cada etapa pode ser uma função Lambda, um serviço da AWS, ou até mesmo um passo personalizado.

```json

{
  "StartAt": "ProcessPayment",
  "States": {
    "ProcessPayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:ProcessPaymentFunction",
      "End": true
    }
  }
}
```

## Processando o Pagamento:
Crie uma função Lambda chamada ProcessPaymentFunction que recebe os detalhes do pagamento, valida-os e retorna o resultado.

```go
package main

import (
 "fmt"
)

func ProcessPayment(paymentDetails map[string]interface{}) (string, error) {
 amount := paymentDetails["amount"].(float64)
 if amount > 0 {
  return "Payment approved", nil
 }

 return "Payment declined", fmt.Errorf("Payment amount is invalid")
}

func main() {
 paymentDetails := map[string]interface{}{
  "amount": 100.0,
  "card":   "1234-5678-9012-3456",
 }

 result, err := ProcessPayment(paymentDetails)
 if err != nil {
  fmt.Println("Error:", err)
 } else {
  fmt.Println(result)
 }
}
```
Nesse exemplo, a função `ProcessPaymentFunction` simplesmente valida se o valor do pagamento é maior que zero para aprovar o pagamento. Este é um exemplo muito básico e simplificado; em um ambiente real, você precisaria adicionar lógica mais robusta para validar os detalhes do pagamento e interagir com serviços externos, como provedores de pagamento ou bancos.

## Rodando o Step Functions:
```go
package main

import (
 "fmt"
 "github.com/aws/aws-sdk-go/aws"
 "github.com/aws/aws-sdk-go/aws/session"
 "github.com/aws/aws-sdk-go/service/sfn"
)

func main() {
 // Configurar uma sessão AWS
 sess := session.Must(session.NewSessionWithOptions(session.Options{
  SharedConfigState: session.SharedConfigEnable,
 }))

 // Criar um cliente do AWS Step Functions
 svc := sfn.New(sess)

 // Definir a ARN do seu fluxo de trabalho do Step Functions
 stateMachineArn := "arn:aws:states:us-east-1:123456789012:stateMachine:ProcessPayment"

 // Definir a entrada para o fluxo de trabalho (no formato JSON)
 input := `{
  "paymentDetails": {
   "amount": 100.0,
   "card": "1234-5678-9012-3456"
  }
 }`

 // Iniciar o fluxo de trabalho
 startInput := &sfn.StartExecutionInput{
  StateMachineArn: aws.String(stateMachineArn),
  Input:           aws.String(input),
 }

 result, err := svc.StartExecution(startInput)
 if err != nil {
  fmt.Println("Error starting execution:", err)
  return
 }

 fmt.Println("Execution started with ARN:", aws.StringValue(result.ExecutionArn))
}
```
Certifique-se de que você tenha configurado as credenciais da AWS corretamente e instalado as dependências `(github.com/aws/aws-sdk-go neste caso)` usando um gerenciador de pacotes Go, como `go get`.

## Conclusão:
O AWS Step Functions é uma ferramenta poderosa para coordenar e orquestrar fluxos de trabalho complexos em suas aplicações. Neste post, demos uma introdução ao conceito de Step Functions e como ele pode ser usado para gerenciar fluxos de trabalho. Além disso, apresentamos um exemplo prático em Golang que demonstra como validar um pagamento de uma compra usando o Step Functions.

Se você está lidando com processos complexos que envolvem várias etapas e serviços, o Step Functions pode ser uma solução valiosa para simplificar a coordenação e melhorar a eficiência de suas aplicações.