PetHouse

Projeto PetShop PetHouse 🐶

Sobre   |    Backend   |    Execução do projeto Backend   |    Execução do projeto Frontend   |    Tecnologias   |    Entre em contato   |   

---

Sobre

Este projeto é uma aplicação Full Stack para um E-commerce de PetShop, desenvolvida com Java, Spring Boot 3+ no backend e Angular no frontend. O objetivo é simular uma plataforma completa onde os usuários podem navegar e realizar compras de produtos para pets de maneira intuitiva e segura.

---

Backend 🔧

Arquitetura de Microsservices PetHouse 🧱

Esta aplicação utiliza uma arquitetura baseada em microsserviços para gerenciar diferentes funcionalidades de forma isolada, garantindo escalabilidade, modularidade e facilidade de manutenção. Abaixo estão os principais microsserviços que compõem o sistema.

Microsservice PetHouse 🏠

Descrição:

Este é o serviço principal da aplicação, responsável por gerenciar grande parte das funcionalidades, incluindo o cadastro de usuários, gerenciamento de produtos, controle do carrinho de compras e envio de mensagens para os tópicos no Kafka.

Microsservice Auth 🔐

Descrição:

Este microsserviço é responsável pela autenticação e autorização dos usuários. Ele gerencia a criação de tokens JWT para controle de sessão e também a renovação de tokens.

Microsservice Payment 💸

Descrição:

Este serviço é responsável por processar os pagamentos dos pedidos feitos pelos usuários. Ele ouve o tópico Kafka Itens para receber detalhes do pedido e então integra com o sistema de pagamentos Assas para completar a transação.

Microsservice Email 📧

Descrição:

Este microsserviço é responsável pelo envio de e-mails personalizados aos usuários, utilizando templates específicos para diferentes eventos. Ele ouve vários tópicos Kafka, como bemVindo, carrinho e vendas, e aciona o envio de e-mails adequados.

---

Fluxo entre Microsserviços 💫

O fluxo de dados entre os microsserviços foi projetado para garantir uma interação eficiente entre as funcionalidades da aplicação, utilizando tópicos no Kafka para comunicação assíncrona entre os serviços. Esse fluxo garante que os microsserviços possam operar de forma desacoplada, mas ainda assim colaborativa.

• 1. Cadastro de Usuários Quando um novo usuário se cadastra na aplicação através do PetHouse Service, os dados do usuário são enviados ao tópico Kafka bemVindo. O Email Service escuta este tópico e envia automaticamente um e-mail de boas-vindas ao usuário.
• 2. Adição de Produtos ao Carrinho Quando o usuário adiciona um produto ao carrinho, o PetHouse Service envia os detalhes do carrinho para o tópico Kafka carrinho. O Email Service escuta este tópico e pode enviar um e-mail de notificação ao usuário com um resumo do carrinho ou lembretes sobre os itens.
• 3. Seleção de Método de Pagamento Após o usuário escolher um método de pagamento, o PetHouse Service envia os dados do pedido para o tópico Kafka Itens. O Payment Service escuta este tópico para processar o pagamento utilizando a integração com o sistema Assas.
• 4. Processamento do Pagamento O Payment Service processa o pagamento e, uma vez que o pedido é confirmado e o pagamento é aprovado, ele envia uma mensagem para o tópico Kafka vendas. Isso aciona tanto o PetHouse Service para atualizar o status do pedido quanto o Email Service para enviar um e-mail de confirmação de compra ao usuário.

Resumo do Fluxo:

Cadastro de Usuário:

Ação: O usuário se cadastra no PetShop. Resultado: O PetHouse Service envia os dados ao tópico bemVindo, acionando o envio de um e-mail de boas-vindas pelo Email Service.

Ação no Carrinho:

Ação: O usuário adiciona produtos ao carrinho. Resultado: O PetHouse Service envia os dados ao tópico carrinho, acionando o Email Service para enviar e-mails de lembrete.

Escolha do Pagamento:

Ação: O usuário seleciona o método de pagamento. Resultado: O PetHouse Service envia os dados para o tópico Itens, que é escutado pelo Payment Service para processar o pagamento.

Confirmação de Pagamento:

Ação: O pagamento é processado com sucesso.

Resultado: O Payment Service envia os dados para o tópico vendas, notificando o Email Service para enviar a confirmação de compra e o PetHouse Service para atualizar o status do pedido.

---

Documentação centralizada com Swagger 📗

Centralizamos a documentação do nosso sistema usando Swagger, proporcionando uma visão unificada e acessível de todos os nossos serviços

2024-10-23-10-36-42.mp4

Acesse a documentação do projeto:

Quando subir a aplicação acesse usando esse link

• Acesse: http://localhost:8080/swagger-ui.html para visualizar os endpoints.

---

Distributed Tracing com ZIPKIN 👁️‍🗨️

Implementação Distributed Tracing no sistema utilizando o Zipkin, uma ferramenta poderosa para monitorar e analisar o fluxo de solicitações em ambientes distribuídos.

2024-10-23-10-39-25.mp4

Acesse a documentação do projeto:

Quando subir a aplicação acesse usando esse link

• Acesse: http://localhost:9411/zipkin/ para visualizar o Zipkin.

---

Migration com Flyway ️‍️✈️

Utilizei o Flyway para gerenciar e versionar as migrações do banco de dados de forma automática e eficiente. Isso garante que o esquema do banco esteja sempre atualizado, permitindo controle de versão e facilidade na aplicação de novas alterações.

---

Upload AWS S3 ☁️

As imagens dos produtos são armazenadas no AWS S3, garantindo um armazenamento seguro, escalável e altamente disponível. O S3 permite que os arquivos de imagens sejam facilmente acessados pela aplicação, proporcionando performance e integridade dos dados.

---

Integração com Assas para Pagamentos 💳

A aplicação está integrada ao Assas, um sistema de gestão de pagamentos que permite processar transações de forma segura e eficiente. Com essa integração, é possível oferecer várias opções de pagamento, como PIX, boleto bancário, e cartão de crédito.

---

Pipeline CI/CD com Jenkins e Push para DockerHub 🐳

A integração contínua e o deploy contínuo (CI/CD) do projeto são gerenciados pelo Jenkins. Esse pipeline é responsável por automatizar o processo de construção da aplicação, empacotamento da imagem Docker, e envio para o DockerHub.

Execução do projeto Backend 🤓

Execute o projeto 👁‍🗨

Pré-requisitos: Java 17 e Docker

Clone o repositório do projeto

git clone https://github.com/AugustoMello09/PetHouse.git

Configurando o projeto local 🏠

Configurando o ambiente:

• Navegue até o diretório do projeto

cd PetHouse/PetHouseBackend

• Acesse todos os diretórios do projeto, utilize o comando cd e o nome do diretório para instalar todas as dependências necessárias:

# exemplo
cd PetHouseBackend/auth

mvn clean package -DskipTest=true

• Acesse o diretório de cada microsserviço (por exemplo, PetHouse, payment). Abra o arquivo de configuração application.yml.

• Modifique as configurações necessárias, como URLs dos serviços dependentes.

Troque para localhost

management:
  tracing:
    sampling:
      probability: 1.0
  zipkin:
    tracing:
      endpoint: http://localhost:9411/api/v2/spans

kafka:
  consumer:
    bootstrap-servers: localhost:29092
  producer:
    bootstrap-servers: localhost:29092

---

Modificando as variáveis de ambiente

AWS S3

• Criação de uma conta da AWS

https://aws.amazon.com/pt/

• Criando um bucket no S3

1 - No console AWS, acessar S3

2 - Create Bucket -> dê um nome e desmarque a opção de Block all public access

• Setup do IAM - Identity Access Management

Acessar o dashboard -> Security, Identity & Compliance -> IAM

• Setup do MFA - Multi-factor authentication (OPCIONAL)

1 - Instalar o Google Authenticator App no seu smartphone

2 - Clicar no botão "Manage MFA" e selecione "A virtual MFA device"

3 - Ler o QR Code a partir do app Google Authenticator

4 - Entrar com dois códigos gerados pelo app e clique em "Activate Virtual MFA"

• Create individual IAM users

1 - Manage users -> Create new users

2 - Crie um usuário para seu sistema acessar o S3 (exemplo: "spring_user")

3 - Baixe o arquivo com as credenciais do usuário (user name, access key id, secret access key)

• Use groups to assign permissions

1 - Manage groups -> Create new group

2 - Criar um grupo (exemplo: "developers")

3 - Busque por "S3" e selecione "AmazonS3FullAccess" e confirme

4 - Selecione o grupo e clique: Group Actions -> Add Users do Group

5 - Selecione o usuário e confirme

• Apply an IAM password policy (OPCIONAL)

  1 - Manage Password Policy

  2 - Selecione as políticas desejadas

• Alterações na políticas de Block do bucket

{
    "Version": "2008-10-17",
    "Statement": [
      {
        "Sid": "AllowPublicRead",
        "Effect": "Allow",
        "Principal": {
        "AWS": "*"
        },
        "Action": [
        "s3:GetObject"
        ],
        "Resource": [
        "arn:aws:s3:::curso-spring-ionic/*"
        ]
      }
   ]
}

Alterando os dados do application.yml do PetHouse

agora com os dados necessários crie as variáveis de ambiente para conseguir usar os serviço da AWS S3

• Depois de ter salvo as variáveis de ambiente entra na PetHouse e coloque os valores das chaves

aws:
  s3:
    access-key: ${AWS_ACCESS_KEY}
    secret-key: ${AWS_SECRET_ACCESS_KEY}
    region: ${AWS_REGION}
    bucket-name: ${AWS_BUCKET_NAME}

Assas

Agora Crie uma conta no ambiente de SendBox do Assas e gere o token de acesso.

https://docs.asaas.com/docs/visao-geral

um vídeo explicativo no canal do Assas https://youtu.be/3TEclkugpkE

• Com o token criado faça a mesma coisa e crie uma nova variavel de ambiente e coloque o valor no yml da PetHouse e também do Payment

access:
  token: ${access_token}

---

Rodando a aplicação

Antes de rodar prepare o docker-compose

services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    networks:
      - broker-kafka
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000

  kafka:
    image: confluentinc/cp-kafka:latest
    networks:
      - broker-kafka
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    healthcheck:
      test: ["CMD", "kafka-broker-api-versions", "--bootstrap-server", "localhost:9092"]
      interval: 10s
      retries: 5
      timeout: 10s
      start_period: 20s

  kafdrop:
    image: obsidiandynamics/kafdrop:latest
    networks:
      - broker-kafka
    depends_on:
      kafka:
        condition: service_healthy
    ports:
      - "19000:9000"
    environment:
      KAFKA_BROKERCONNECT: kafka:29092

  zipkin-service:
    image: openzipkin/zipkin:latest
    container_name: zipkin-service
    ports:
      - 9411:9411
    healthcheck:
      test: ["CMD", "wget", "--spider", "-S", "http://zipkin-service:9411/"]
      interval: 5s
      retries: 5
      timeout: 10s
      start_period: 0s
    depends_on:
      kafka:
        condition: service_healthy
    networks:
      - broker-kafka

networks:
  broker-kafka:
    driver: bridge

• Primeiro Suba o docker com o comando docker-compose up -d

• Suba os microsservices na seguinte ordem:

euraka, gateway, auth, PetHouse, payment e email com o container rodando.

# Exemplo para o PetHouse

cd PetHouseBackend/PetHouse

mvn spring-boot:run

Configurando o projeto para usar Docker-compose 🐳

Clone o repositório do projeto

git clone https://github.com/AugustoMello09/PetHouse.git

• Navegue até o diretório do projeto

cd PetHouse/PetHouseBackend

• Navegue até o diretório de cada projeto e troque o localhost pelo nome do service que está no docker-compose

management:
  tracing:
    sampling:
      probability: 1.0
  zipkin:
    tracing:
      endpoint: http://zipkin-service:9411/api/v2/spans

      kafka:
         consumer:
           bootstrap-servers: kafka:29092
         producer:
           bootstrap-servers: kafka:29092

• Agora com os dados gerados anteriormente entre em cada diretório, faça build e Build da docker-img

# exemplo

cd PetHouse/PetHouseBackend

cd eureka

mvn clean package -DskipTest=true

docker build -t seu usuário do DockerHub/pethouse-backend-eureka .

docker push seu usuário do DockerHub/pethouse-backend-eureka:latest

• Configure o docker-compose com sua img

services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    networks:
      - broker-kafka
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000

  kafka:
    image: confluentinc/cp-kafka:latest
    networks:
      - broker-kafka
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    healthcheck:
      test: ["CMD", "kafka-broker-api-versions", "--bootstrap-server", "localhost:9092"]
      interval: 10s
      retries: 5
      timeout: 10s
      start_period: 20s

  kafdrop:
    image: obsidiandynamics/kafdrop:latest
    networks:
      - broker-kafka
    depends_on:
      kafka:
        condition: service_healthy
    ports:
      - "19000:9000"
    environment:
      KAFKA_BROKERCONNECT: kafka:29092

  zipkin-service:
    image: openzipkin/zipkin:latest
    container_name: zipkin-service
    ports:
      - 9411:9411
    healthcheck:
      test: ["CMD", "wget", "--spider", "-S", "http://zipkin-service:9411/"]
      interval: 5s
      retries: 5
      timeout: 10s
      start_period: 0s
    depends_on:
      kafka:
        condition: service_healthy
    networks:
      - broker-kafka

  eureka-service:
    build:
      dockerfile: ./eureka/Dockerfile
      context: .
    image: seu usuário/pethouse-backend-eureka:latest
    container_name: eureka-service
    ports:
      - 8761:8761
    networks:
      - broker-kafka

  gateway-service:
    build:
      dockerfile: ./gateway/Dockerfile
      context: .
    image: seu usuário/pethouse-backend-gateway:latest
    container_name: gateway-service
    environment:
      - eureka.client.fetch-registry = true
      - eureka.client.register-with-eureka = true
      - eureka.client.serviceUrl.defaultZone = http://eureka-service:8761/eureka
      - spring.zipkin.base-url = http://zipkin-service:9411/api/v2/spans
    ports:
      - 8080:8080
    networks:
      - broker-kafka
    depends_on:
      eureka-service:
        condition: service_started
      zipkin-service:
        condition: service_healthy

  auth-service:
    build:
      dockerfile: ./auth/Dockerfile
      context: .
    image: seu usuário/pethouse-backend-auth:latest
    container_name: auth-service
    environment:
      - eureka.client.service-url.defaultZone = http://eureka-service:8761/eureka
      - spring.zipkin.base-url = http://zipkin-service:9411/api/v2/spans
    networks:
      - broker-kafka
    depends_on:
      eureka-service:
        condition: service_started
      zipkin-service:
        condition: service_healthy

  pethouse-service:
    build:
      dockerfile: ./PetHouse/Dockerfile
      context: .
    image: seu usuário/pethouse-backend-pethouse:latest
    container_name: pethouse-service
    environment:
      - spring.kafka.bootstrap-servers=kafka:29092
      - eureka.client.service-url.defaultZone=http://eureka-service:8761/eureka
      - spring.zipkin.base-url=http://zipkin-service:9411/api/v2/spans
    networks:
      - broker-kafka
    depends_on:
      kafka:
        condition: service_healthy
      eureka-service:
        condition: service_started
      zipkin-service:
        condition: service_healthy
      gateway-service:
        condition: service_started

  payment-service:
    build:
      dockerfile: ./payment/Dockerfile
      context: .
    image: seu usuário/pethouse-backend-payment:latest
    container_name: payment-service
    environment:
      - spring.kafka.bootstrap-servers=kafka:29092
      - eureka.client.service-url.defaultZone=http://eureka-service:8761/eureka
      - spring.zipkin.base-url=http://zipkin-service:9411/api/v2/spans
    networks:
      - broker-kafka
    depends_on:
      eureka-service:
        condition: service_started
      zipkin-service:
        condition: service_healthy
      kafka:
        condition: service_healthy
      pethouse-service:
        condition: service_started
      gateway-service:
        condition: service_started

  email-service:
    build:
      dockerfile: ./email/Dockerfile
      context: .
    image: seu usuário/pethouse-backend-email:latest
    container_name: email-service
    environment:
      - spring.kafka.bootstrap-servers=kafka:29092
      - eureka.client.service-url.defaultZone=http://eureka-service:8761/eureka
      - spring.zipkin.base-url=http://zipkin-service:9411/api/v2/spans
    networks:
      - broker-kafka
    depends_on:
      eureka-service:
        condition: service_started
      zipkin-service:
        condition: service_healthy
      kafka:
        condition: service_healthy
      pethouse-service:
        condition: service_started
      payment-service:
        condition: service_started


networks:
  broker-kafka:
    driver: bridge

Execução do projeto Frontend 🤪

Execute o projeto 👁

Pré-requisitos: Angular

Executar

• Certifique-se de ter o Node.js e o Angular CLI instalados em seu ambiente.
• Navegue até a pasta do projeto front-end:

cd PetHouse/PethouseFrontend

Instale as dependências do projeto:

npm install

---

Tecnologias

‍

---

Entre em contato

contato

Para mais informações sobre o projeto ou para entrar em contato, você pode me encontrar através dos canais abaixo: