DEV Community: Thiago Souza

Spring Boot + Docker + AWS EC2

Thiago Souza — Wed, 26 Apr 2023 19:23:33 +0000

Introdução

Salve galera! Nesse post vou tentar demostrar como publicar uma Api Spring Boot utilizando Docker, DockerHub e uma instância do EC2 da AWS. Então seguem os passos que vamos seguir para publicar a Api.

Criar um projeto Spring Boot
Criar uma imagem com Dockerfile
Publicar a imagem no DockerHub
Configurar uma instância EC2 na AWS e colocar a API em produção

Vamos Lá!

Criando o projeto

Para criação do projeto vamos utilizar a plataforma Spring Initializr e criar um projeto simples utilizando maven e java 17 e com apenas uma dependência conforme abaixo.

O projeto consiste em uma pequena Api que vai consultar dados sobre Pokemons em uma outra Api bem famosa, a PokéApi. Faremos a consulta passando o nome do pokemon para um controller get na nossa api.

PokemonControler

@RestController
public class PokemonController {

    @Autowired
    PokemonService pokemonService;

    @GetMapping("pokemon-info")
    public String GetPokemonInfo(@RequestParam String pokemonName){

        return pokemonService.GetPokemonInfo(pokemonName);
    }
}

Dentro do nosso controller temos uma injeção de dependência para nossa classe service que por sua vez acionará nosso repository que buscará os dados.

PokemonService

@Service
public class PokemonService {

    @Autowired
    PokemonRepository pokemonRepository;
    public String GetPokemonInfo(String pokemonName) {
      return pokemonRepository.GetPokemonInfo(pokemonName);
    }
}

Por último temos nosso PokemonRepository, geralmente é aqui que fazemos o acesso ao banco de dados, mas como a Api é simples vamos simular esse acesso aos dados com uma chamada para outra Api passando o nome do pokemon recebido pelo controller.

PokemonRepository

@Repository
public class PokemonRepositoryImplementation implements PokemonRepository {

    @Autowired
    private Environment env;

    @Override
    public String GetPokemonInfo(String pokemonName) {
        try {
          return  new RestTemplate().getForObject(env.getProperty("baseUrl")+pokemonName, String.class);
        }catch (HttpClientErrorException error){
            if (error.getStatusCode() == HttpStatus.NOT_FOUND) {
                throw new ResponseStatusException(HttpStatus.NOT_FOUND);
            } else {
                throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
            }
        }

    }
}

O código completo pode ser encontrado no meu GitHub

2. Criar a imagem com Dockerfile

Vamos criar um arquivo na raiz do projeto com o nome Dockerfile sem extensão. Dentro desse arquivos vamos incluir os comandos Docker para geração da imagem que será enviada para o DockerHub e posteriormente carregada dentro de um container na nossa instância EC2 na AWS.

Dockerfile

Dentro do arquivo vamos entender o que faz cada comando:

FROM openjdk:17 -> Indica que vamos construir nossa imagem a partir do jdk 17 necessário para que a nossa Api seja executada no container.

WORKDIR /app -> Cria o repositório app dentro do nosso container para onde vamos copiar nossos arquivos .jar compliados.

COPY /target/demo-0.0.1-SNAPSHOT.jar /app/api.jar -> Aqui estamos copiando nosso jar de dentro da pasta onde ele foi gerado, para dentro do repositório criado no nosso comando anterior.

EXPOSE 8080 -> Expondo a porta onde nossa aplicação ficará disponível.

ENTRYPOINT ["java","-jar", "api.jar"] -> Executando nosso arquivo .jar criado para que nossa aplicação seja iniciada.

Antes de utilizarmos o Dockerfile para criar nossa imagem, precisamos construir o nosso .jar com nosso código fonte compilado, para isso utilizaremos o comando mvn clean install isso deve gerar nossos arquivos dentro do diretório target do projeto.

A partir de agora precisaremos estar com o Docker instalado e rodando em nossa máquina, pois vamos fazer build utilizando nosso Dockerfile para efetivamente gerar a imagem que será posteriormente enviada ao DockerHub. É necessário também possuir uma conta no DockerHub pois vamos precisar efetuar o login na nossa conta para fazer o push da imagem.

Abra o terminal e execute o seguinte comando docker build -t pokemon-api . esse comando vai gerar nossa imagem com o nome pokemon-api utilizando nosso Dockerfile criado anteriormente.

Podemos agora executar o comando docker images e verificar que nossa imagem foi criada com. sucesso!

3. Publicar a imagem no DockerHub

Agora que temos a nossa imagem gerada, vamos subir para a nossa conta no DockerHub. Precisamos fazer login na nossa conta, então vamos rodar o comando docker login dentro do terminal, nossas credenciais serão solicitadas após isso já poderemos efetuar o push da imagem para nossa conta.

Vamos marcar a imagem com uma tag que será importante na hora de fazer o pull dentro da nossa instância de EC2. O padrão para esse comando é: docker tag <image_id> <dockerhub_username>/<image_name>:<tag>, onde image_id é o ID da imagem que desejamos marcar, no meu caso, o comando ficaria assim: docker tag c8a7b3f87156 thiagosouzasi/pokemon-api:0.0.1. Estou utilizando a tag para versionar a nossa imagem com 0.0.1.

Agora que a imagem já possui a tag, vamos fazer o push para nosso repositório. Pra isso vamos utilizar o comando docker push thiagosouzasi/pokemon-api:0.0.1. Lembrando que precisamos estar logados na nossa conta para que o processo funcione.

Pronto, agora temos nossa imagem publicada dentro do DockerHub.

4. Configurar uma instância EC2 na AWS e colocar a API em produção.

Finalmente chegou a hora de publicarmos nossa Api, para isso é preciso inicialmente possuir uma conta na AWS.

Com a conta criada vamos navegar até o console e digitar EC2 na busca. Dentro do EC2 vamos clicar em Executar Instância para criar uma nova Instância de EC2.

Informamos o nome da instância e escolheremos o tipo Amazon Linux. Devemos ainda selecionar o tipo t2.micro, assim, conseguiremos publicar a Api sem custos.

Posteriormente precisamos configurar o login sem atribuir chaves de acesso, atenção esse tipo de configuração não é recomendado em projetos reais por deixar brechas de segurança, contudo, por hora isso será o suficiente e facilitará a conexão com a instância que será feita mais a frente.

Após isso basta clicar em executar instância.

Adicionaremos ainda outra configuração importante, devemos liberar a porta http(80) da nossa instância para habilitar o acesso externo. Mais a frente faremos o mapeamento dessa porta para a porta do container que deverá rodar nossa APi.

Selecione a instância criada, e navegue até a aba segurança.

Em grupo de segurança clicamos em launch-wizard vai ser aberta uma tela onde vamos configurar uma regra de entrada.

Na tela a seguir vamos selecionar regras de entrada e clicar em editar regras de entrada

Vamos adicionar a regra para protocolo http (80) e salvar a configuração.

Agora já estamos com o EC2 configurado, selecione a instância criada e vá em conectar. Agora instalaremos o Docker, faremos o pull da imagem do Dockerhub e executaremos nossa Api.

Uma vez conectados basta executar uma sequência de comandos:

Primeiro vamos alternar para o modo root no terminal com o comando sudo -i
Agora vamos atualizar os pacotes da máquina com o comando sudo yum update -y
Na sequência vamos instalar o Docker na EC2 com o comando sudo yum install docker. Após o download e instalação dos pacotes podemos verificar se a instalação foi bem sucedida executando o comando docker -v.

Vamos agora iniciar o Docker com o comando sudo service docker start

Docker rodando, vamos fazer o pull da nossa imagem salva no Dockerhub, para isso precisaremos efetuar novamente o login na nossa conta do Dockerhub com o mesmo comando que utilizamos na nossa máquina local docker login. Uma vez logados vamos buscar a imagem, o comando pode ser encontrado no próprio Dockerhub onde salvamos a imagem.

Vamos rodar o comando docker pull thiagosouzasi/pokemon-api:0.0.1 substituindo o tag name pela tag da versão da imagem que configuramos anteriormente.

A imagem será baixada para nossa instância, ao final do processo podemos ainda conferir se deu tudo certo rodando o comando docker images.

Chegamos à última etapa, vamos subir um container utilizando nossa imagem para finalmente colocar nossa Api em produção!

Rode o comando docker run -d -p 80:8080 thiagosouzasi/pokemon-api:0.0.1

Com esse comando estamos subindo nosso container na porta 8080, mesma porta configurada na nossa api spring boot e estamos mapeando essa porta para a porta 80 da instância EC2, justamente por isso configuramos a regra de entrada nas etapas anteriores. Dessa forma todo tráfego que chegar na porta http padrão será direcionado para a api no nosso container.

Foi utilizada ainda a flag -d para que nosso container suba em modo detached e permaneça rodando mesmo quando fecharmos o terminal do EC2.

Pronto, é chegada a hora da verdade! Agora basta pegar DNS IPv4 público da nossa instância e fazer uma requisição passando o nome de um pokemon que vc conhece para ver se está tudo funcionando.

Por hoje é isso pessoal!

React - useEffect vs useLayoutEffect

Thiago Souza — Sun, 09 Oct 2022 19:42:14 +0000

Introdução

Olá pessoal, hoje darei início a uma pequena série de posts sobre React, tecnologia que eu trabalho atualmente. Vamos falar um pouco sobre hooks, hoje mais precisamente sobre os hooks useEffect (muito difundido e utilizado) e o useLayoutEffect (bem menos conhecido e utilizado).

Funcionamento

Olhando os hooks de maneira um pouco menos criteriosa temos a impressão de que ambos funcionam da mesma maneira, inclusive apresentam nomes e assinaturas bem semelhantes.

function MyComponent(){

  useEffect(()=>{
    //função de efeito
    soma()
  },[])//array de dependências


  useLayoutEffect(()=>{
     //função de efeito
     soma()
  },[])//array de dependências


  function soma(a,b){
    return a+b
  }
}

Para além das semelhanças de sintaxe, ambos possuem comportamento bem similar, e isso pode confundir o desenvolvedor desatento. Olhando rapidamente, o funcionamento dos dois é "exatamente o mesmo"! Executam uma uma função de efeito no primeiro render do componente, e tornam a executar essa função sempre que alguma das dependências do array de dependências sofrer alteração.

Qual a diferença?

De maneira bem prática, existem duas diferenças entre os hooks, uma é o momento do lifecycle (Ciclo de vida do componente) em que eles são executados e a outra diferença é que um tem o funcionamento síncrono e o outro tem funcionamento assíncrono.

Para entender melhor é necessário uma breve explicação sobre o lifecycle. Sempre que uma renderização acontece em um componente React, seja o primeiro render ou um render disparado por alterações nas props ou states, uma série de ações são executadas por baixo dos panos até que o usuário visualize as mudanças em tela, é isso que chamamos de lifecycle do componente. Isso posto vamos agora entender a diferença entre os dois hooks, e a principal delas é justamente o momento dentro desse lifecycle onde cada um dos hooks é disparado.

useEffect

No caso do useEffect a função de efeito é disparada após as alterações visuais do componente já terem sido aplicadas na tela, portanto já visíveis ao usuário.

useLayoutEffect

Já quando estamos tratando do useLayoutEffect esse comportamento se altera. A função de efeito será chamada sempre antes de o usuário enxergar as alterações na tela.

Outra diferença do useLayoutEffect é que ele é síncrono, o que na prática indica que o próximo passo do lifecycle (usuário ver as alterações em tela) só acontece quando a função de efeito disparada for finalizada. Já no caso do useEffect isso não acontece pois seu comportamento é assíncrono.

Então qual utilizar?

O próprio React recomenda a utilização do useEffect em 99% dos casos, pois o comportamento síncrono do useLayoutEffect que bloqueia o fluxo de renderização pode passar ao usuário a impressão de que a aplicação está "travada" quando na verdade a tela está esperando a função de efeito terminar de executar para finalizar a renderização. Contudo sempre existem cenários específicos onde pode ser necessário aguardar a finalização de algum processamento antes de exibir os dados na tela, aí nesses casos seria interessante lançar mão do useLayoutEffect.

Finalizando

Por hoje é isso pessoal, nós próximos posts falaremos mais sobre o useEffect que teve seu comportamento alterado na versão 18 do React

O que devo estudar para iniciar na programação?

Thiago Souza — Sat, 24 Sep 2022 20:19:51 +0000

Olá comunidade! Estou no mundo do desenvolvimento desde o agora longínquo ano de 2012, durante esse tempo ouvi a pergunta do título acima inúmeras vezes, essa e muitas outras relacionadas como: Começo com qual linguagem? Preciso fazer faculdade? Qual linguagem é mais simples? Demora muito pra aprender? etc. Ainda durante esse período trabalhando com desenvolvimento necessitei migrar de linguagem várias vezes (O que para alguns é sempre um novo começo), passei pelo C na faculdade, Java, Php, Delphi, JavaScript, TypeScript, React, React Native. Sempre que estava fazendo essa migração me lembrava das palavras de um professor na faculdade: "Você não deve se preocupar em aprender a linguagem, preocupe-se em aprender a PROGRAMAR!". E, realmente é esse o segredo! Se aprendemos a programar, a linguagem passa a ser secundária, ela se transforma simplesmente em SINTAXE! Abaixo vou tentar responder algumas das perguntas que mais ouvi ok?

Por onde eu começo?

Hoje temos uma oferta gigante de conteúdos pagos e gratuitos sobre desenvolvimento na internet, muitas vezes o desenvolvedor iniciante sente-se perdido sem saber o que realmente tem importância, o que estudo primeiro? Outro fator que atrapalha é o fato de escolher um curso que vai ensinar a LINGUAGEM, não a programar! Antes de escolher um curso para aprender a "linguagem da moda", dê um passo atrás e aprenda a programar antes de aprender a linguagem. Estude lógica de programação, aprenda as estruturas básicas. Veja, se uma pessoa sabe dirigir, ela pode trocar de carro e conseguirá dirigir um carro diferente, mesmo que isso exija uma certa curva de aprendizado e adaptação. Com as linguagens acontece basicamente isso! (É, eu sei, a curva de aprendizado pode ser maior ao trocar de linguagem mas a metáfora ainda vale!)
Enfim, aprenda a lógica, as estruturas de dados, estruturas de repetição, estruturas de desvio de fluxo, tipos de dados pois no final das contas é isso que o programador utiliza no seu cotidiano independente da LINGUAGEM!

Preciso ter faculdade?

Bem gente, esse tema é polêmico e já adianto que, como eu fiz, não conheço muito o outro lado da força rs! Contudo trabalho com profissionais muito competentes que não cursaram faculdade, mas... acredito que a faculdade seja sim facilitador e se você aí iniciante puder FAÇA! Os cursos superiores oferecem aos alunos um encadeamento lógico dos conhecimentos além de focar bastante justamente nos aspectos mencionados no tópico anterior, criando uma base sólida de conhecimentos indispensáveis a todo dev, ou seja oferece uma trilha a ser percorrida durante o curso facilitando a assimilação do conhecimento. Além disso, o curso vai agregar conhecimentos em outras áreas, que também serão importantes na caminhada profissional de um desenvolvedor. É importante aprender sobre administração, matemática, inglês etc. Mas... CUIDADO os cursos superiores tem uma tendência de serem muito teóricos, então tenha em mente que será preciso colocar a mão na massa e praticar tudo que for visto durante o curso OK?

Mas afinal, qual linguagem escolher?

Bem, após adquirir os conhecimentos que mencionei acima, finalmente chega a hora de programar de VERDADE! E aí uma linguagem faz-se necessária! Aqui, meu conselho é realizar uma pesquisa no mercado, veja quais linguagens estão sendo mais utilizadas, veja as que as empresas mais utilizam e faça a sua escolha! Nesse ponto escolher uma linguagem com tipagem dinâmica e fraca pode ajudar o dev iniciante a enfrentar menos problemas e se frustrar menos no início. Hoje no mercado temos o JavaScript e o Python (tipagem dinâmica mas forte!) que na minha visão são excelentes portas de entrada por serem mais flexíveis e permissivas com pequenos deslizes do programador iniciante!

Finalizando

Agora um último conselho, seja qual for a linguagem PROGRAME! De nada adianta ter feito mil cursos apenas assistindo aulas, ou ter lido uma montanha de livros e artigos, o que vai te dar fluência em programação, aqui de novo INDEPENDENTE DA LINGUAGEM, é a prática! É na prática que você vai sentir as dores do dia a dia e aprender com elas para se tornar a cada dia um programador melhor.

Por hoje é isso pessoal, lembrando que o exposto nesse humilde post é minha OPINIÃO com base no que vivenciei ao longo da minha trajetória no desenvolvimento e tem o intuito de ajudar padawans iniciantes ! Até Mais!