Executando a infraestrutura

Requisitos

• AWS CLI - Instalação
• Terraform - Instalação
• Conta na AWS

Começando

Criar credenciais da AWS

Caso já possua credenciais da AWS, pule para Configurar credenciais da AWS. Caso contrário, siga os passos abaixo para criar as credenciais.

1. Acesse o painel da AWS, clique no seu nome de usuário e selecione a opção "Credenciais de segurança".

   

2. Role a página até a seção "Chaves de acesso" e clique em "Criar chave de acesso".

   

3. Selecione "Command Line Interface (CLI)", role a página até o final, selecione a caixa: "Compreendo a recomendação acima e quero prosseguir para criar uma chave de acesso" e clique em "Próximo"

4. Crie uma descrição (opcional)

5. Clique em "Criar chave de acesso"

   Atenção

   Atenção: Após criar a chave de acesso, será exibida a chave de acesso secreta. Guarde-a em um local seguro, ela dá acesso total a conta AWS . Não será possível recuperá-la posteriormente.

6. No final da página é possível baixar o arquivo CSV com as credenciais. Lembrando de guardar a chave de acesso em um local seguro.

Configurar credenciais da AWS

Para começar a utilizar o AWS CLI é necessário configurar as credenciais da AWS. Para isso, execute o comando aws configure e insira as credenciais da sua conta da AWS.

As credenciais serão salvas no arquivo ~/.aws/credentials, para Linux e Mac e C:\Users\USERNAME\.aws\config para Windows. Com elas configuradas, o AWS CLI e o Terraform já podem ser utilizados para criar a infraestrutura. A vantagem de configurar as credenciais é que não será necessário passar as credenciais para o Terraform, evitando que elas possam ser expostas, além de que será necessário utilizar o AWS CLI posteriormente.

Executando o código

Com o código pronto, é hora de executá-lo. Para isso, execute os seguintes comandos no caminho ./terraform :

Para inicializar o terraform e baixar os plugins necessários:

terraform init

Para visualizar o que será criado:

terraform plan

Para criar a infraestrutura (o parâmetro --auto-approve é opcional e serve para não precisar confirmar a criação):

terraform apply --auto-approve

O processo de criação pode demorar em torno de 10 minutos. No momento em que aparecer no terminal a mensagem de que o ambiente do beanstalk está sendo criado, algo similar a: module.elastic_beanstalk.aws_elastic_beanstalk_environment.environment: Still creating... [10s elapsed], é possível acompanhar o processo pelo console da AWS, na página do Beanstalk e clicando no ambiente que está sendo criado é possível ver a mágica acontecendo:

Após o término do processo, irá ser exibido no terminal a mensagem:

Apply complete! Resources: 19 added, 0 changed, 0 destroyed.

Outputs:

aws_command = "aws elasticbeanstalk update-environment --application-name app-beanstalk --version-label v1 --environment-name beanstalk-environment"

O valor que está sendo exibido em aws_command é o comando que deve ser executado para atualizar o ambiente do beanstalk com a nova versão do código. Para isso, copie o comando (sem as aspas), cole no terminal e execute. Como o Terraform não tem a capacidade de atualizar o ambiente do beanstalk, é necessário executar esse comando manualmente.

Após a execução do comando, o ambiente do beanstalk será atualizado e o código estará rodando na AWS.

Aplicação de teste

A aplicação de teste é um código em Flask que foi feito da seguinte forma:

• Realiza os imports necessários
  application.py

     import os
     from flask import Flask, request
     import redis
  

• Conecta com o Redis utilizando a variável de ambiente REDIS_ENDPOINT criada no terraform
  application.py

      # Redis connection
      endpoint = os.environ['REDIS_ENDPOINT']
  
      # Connect to Redis
      redis_client = redis.Redis(host=endpoint, port=6379)
  

• Cria o app e uma rota para o endpoint / que retorna uma mensagem de como usar a aplicação

  application.py

      # print a nice greeting.
      def say_hello(username = "World"):
          return '<p>Hello %s!</p>\n' % username
  
      # some bits of text for the page.
      header_text = '''
          <html>\n<head> <title>EB Flask Test</title> </head>\n<body>'''
      instructions = '''
          <p>Para colocar algo no cache basta fazer uma requisição
          com o método POST na rota /store com o body da seguinte forma:</p>
          <p>key: [chave] </p>
          <p>value: [valor]</p>
          <p>Para retornar o valor a partir da chave faça uma requisição
          com o método GET na rota: /retrieve/[key] , sendo key a chave do valor no cache,
          sem os colchetes.</p>\n'''
      footer_text = '</body>\n</html>'
  
      # EB looks for an 'application' callable by default.
      application = Flask(__name__)
  
      # add a rule for the index page.
      application.add_url_rule('/', 'index', (lambda: header_text +
          say_hello() + instructions + footer_text))
  

• Cria uma rota para o endpoint /store que recebe uma requisição do tipo POST, armazena o valor no Redis e retorna uma mensagem de sucesso
  

  application.py

      # path to store data in cache
      @application.route('/store', methods=['POST'])
      def store():
          value = request.form['value']
          key = request.form['key']
          redis_client.set(key, value)
          return f"Stored {value} in {key}"
  

• Cria uma rota para o endpoint /retrieve/<key> que recebe uma requisição do tipo GET, busca o valor no Redis a partir da chave e retorna o valor

  application.py

      # path to retrieve data from cache
      @application.route('/retrieve/<key>', methods=['GET'])
      def retrieve(key):
          value = redis_client.get(key)
          if value:
              return f"Retrieved {value} from {key}"
          return f"Key {key} not found"
  

Testando a aplicação

Para os testes foi utilizado o Postman, mas é possível utilizar qualquer ferramenta que consiga fazer requisições HTTP. Para obter o url da aplicação, basta acessar o console da AWS, ir na página do Beanstalk e clicar no ambiente que foi criado. Na página do ambiente, na aba Configuration é possível ver o url da aplicação:

Copie esse valor e cole no Postman. Selecione o método POST, coloque a rota /store, no body selecione form-data, na primeira linha na coluna key coloque key e na coluna value coloque teste e na segunda linha na coluna key coloque value e na coluna value coloque testando. O resultado deve ser algo similar a:

Clique em Send e o resultado deve ser algo similar a:

Agora, para recuperar o valor armazenado, selecione o método GET, coloque a rota /retrieve/teste e clique em Send. O resultado deve ser algo similar a:

Com isso é possível ver que a aplicação está funcionando corretamente.

Alarmes do CloudWatch

Para validar que os alarmes do CloudWatch estão funcionando acesse o console da AWS, vá na página do CloudWatch e clique em Todos os alarmes no menu lateral, é possível ver os alarmes que foram criados:

Removendo a infraestrutura

Para remover a infraestrutura criada, basta executar o comando:

terraform destroy

Após a execução do comando, será exibido no terminal a mensagem:

Destroy complete! Resources: 19 destroyed.

Com isso, a infraestrutura será removida da AWS.