Merge pull request #43 from fiap-8soat-tc-one/feature/k6-auto-testing

Feature/k6 auto testing

.github/workflows/github-pipeline.yml

@@ -0,0 +1,63 @@
+name: Publish Docker image
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+
+jobs:
+  push_to_registry:
+    name: Push Docker image to Docker Hub
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: write
+      attestations: write
+      id-token: write
+
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v4
+
+      - name: Set up the date and revision tag
+        id: vars
+        run: |
+          DATE_TAG=$(date +'%Y%m%d')
+          REVISION_TAG=$(cat REVISION_TAG || echo "0")
+          REVISION_TAG=$((REVISION_TAG + 1))
+          echo "${REVISION_TAG}" > REVISION_TAG
+          echo "TAG=${DATE_TAG}.${REVISION_TAG}" >> $GITHUB_ENV
+
+      - name: Set up Docker Build
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          load: true
+          tags: |
+             ${{ secrets.DOCKER_USERNAME }}/fiap-8soat-tc:backend-${{ env.TAG }}
+             ${{ secrets.DOCKER_USERNAME }}/fiap-8soat-tc:latest
+          platforms: linux/amd64
+
+      - name: Push Docker image (amd64)
+        run: |
+          docker push  ${{ secrets.DOCKER_USERNAME }}/fiap-8soat-tc:backend-${{ env.TAG }}
+          docker push  ${{ secrets.DOCKER_USERNAME }}/fiap-8soat-tc:latest
+
+      - name: Commit revision tag
+        run: |
+          git config --global user.name "GitHub Actions"
+          git config --global user.email "actions@github.com"
+          git tag release-${{ env.TAG }}
+          git push origin release-${{ env.TAG }}

.gitignore

@@ -10,4 +10,5 @@
 .vscode/
 target/
 code_quality_service/
-.DS_Store
+.DS_Store
+qodana.yaml

Dockerfile

@@ -1,19 +1,21 @@
 FROM maven:3.8.4-openjdk-17-slim AS build
-
 WORKDIR /app
-
 COPY pom.xml /app/pom.xml
-
 RUN mvn dependency:go-offline
-
 COPY src /app/src
-
 RUN mvn clean package -DskipTests
 
 FROM openjdk:17-jdk-slim AS deploy
 
-WORKDIR /app
+LABEL org.opencontainers.image.title="TC Backend API"
+LABEL org.opencontainers.image.description="Backend API para o projeto TC da FIAP 8SOAT"
+LABEL org.opencontainers.image.version="1.0.0"
+LABEL org.opencontainers.image.url="https://github.com/fiap-8soat-tc-one/tc-backend-s2"
+LABEL org.opencontainers.image.source="https://github.com/fiap-8soat-tc-one/tc-backend-s2"
+LABEL org.opencontainers.image.created="2024-09-03"
+LABEL org.opencontainers.image.authors="FIAP 8SOAT TEAM 32"
+LABEL org.opencontainers.image.licenses="GNU General Public License v3.0"
 
+WORKDIR /app
 COPY --from=build /app/target/*.jar /app/tc-backend-api.jar
-
-ENTRYPOINT ["java", "-jar", "tc-backend-api.jar"]
+ENTRYPOINT ["java", "-jar", "tc-backend-api.jar"]

REVISION_TAG

@@ -0,0 +1 @@
+3

docker-compose.yml

@@ -23,8 +23,8 @@ services:
     depends_on:
       postgres:
         condition: service_healthy
-    image: tc-backend
-    build: .
+    image: jcmds/fiap-8soat-tc
+    container_name: tc-backend
     ports:
       - 8080:8080
     restart: always

docs/clean-arch/README.md

@@ -0,0 +1,94 @@
+# Clean Architecture: Vantagens e Estrutura Detalhada
+
+Clean Architecture, proposta por Robert C. Martin (Uncle Bob), é uma abordagem de design de software que visa criar sistemas altamente flexíveis, escaláveis e de fácil manutenção. Ela organiza o código em camadas de responsabilidade bem definidas, mantendo as regras de negócio isoladas dos detalhes de implementação técnica, como frameworks, bancos de dados ou interfaces externas.
+
+## Estrutura do Clean Architecture
+
+A arquitetura é organizada em torno de camadas concêntricas, onde a dependência entre as camadas segue a regra da dependência: **camadas externas podem depender de camadas internas, mas não o contrário**. A camada mais interna contém a lógica de negócios, enquanto a camada mais externa lida com frameworks, UI, e outras interfaces externas. As principais camadas são:
+
+**Segue abaixo como foi estrutura a aplicação**
+
+![image](https://github.com/fiap-8soat-tc-one/tc-backend-s2/blob/main/assets/clean-arch.png)
+
+### 1. Entidades (Entities)
+
+- São objetos de negócios que encapsulam as regras e políticas mais gerais do sistema.
+- Representam o núcleo da aplicação e são independentes de frameworks e bibliotecas externas.
+- **Exemplo**: No domínio de uma aplicação bancária, uma "Conta" é uma entidade que possui regras como o cálculo de saldo.
+
+### 2. Casos de Uso (Use Cases)
+
+- Esta camada contém a lógica específica de aplicação, como fluxos de operações que o sistema realiza (Ex.: criar uma conta, transferir dinheiro).
+- É responsável por coordenar a interação entre as entidades, sem se preocupar com como as informações são exibidas ou armazenadas.
+- **Exemplo**: Um caso de uso poderia ser a "Transferência de Fundos", que precisa orquestrar interações entre múltiplas entidades.
+
+### 3. Adaptadores de Interface (Interface Adapters)
+
+- Esta camada converte dados entre o formato que as camadas internas esperam e o formato das camadas externas (ex.: API, UI, banco de dados).
+- Contém controladores, presenters e gateways que servem de ponte entre a lógica de negócios e os sistemas externos.
+- **Exemplo**: Um adaptador de interface converteria uma requisição HTTP em uma chamada a um caso de uso.
+
+### 4. Frameworks e Drivers (Infrastructure)
+
+- A camada mais externa contém detalhes específicos da implementação, como frameworks, banco de dados, bibliotecas externas, APIs, etc.
+- A ideia é que esses componentes sejam tratados como detalhes que podem ser facilmente substituídos.
+- **Exemplo**: Um ORM como o Entity Framework estaria nesta camada, fornecendo a persistência de dados, mas sem impactar o núcleo da aplicação.
+
+## Vantagens de Aplicar o Clean Architecture
+
+### 1. Independência de Frameworks
+
+- Clean Architecture coloca os frameworks e bibliotecas externas como "detalhes" e não como parte central da aplicação. Isso facilita a substituição de tecnologias sem grandes impactos na lógica do negócio.
+- **Exemplo**: Se você está usando o Entity Framework para persistência de dados e decide trocar por outro ORM, isso não afetará as camadas de negócio.
+
+### 2. Fácil Manutenção e Evolução
+
+- Como as regras de negócios estão separadas dos detalhes de infraestrutura, o código torna-se mais fácil de manter. Mudanças na UI ou no banco de dados podem ser feitas sem impactar a lógica central da aplicação.
+- **Exemplo**: Se precisar alterar a interface de usuário, não será necessário mudar os casos de uso ou as entidades.
+
+### 3. Alta Testabilidade
+
+- A separação entre camadas permite que cada uma seja testada de forma isolada. A camada de regras de negócio (entidades) pode ser testada independentemente da camada de banco de dados ou interface, permitindo a criação de testes unitários robustos.
+- **Exemplo**: Pode-se testar as regras de transferência bancária sem precisar configurar um banco de dados real ou uma interface gráfica.
+
+### 4. Facilidade para Mudanças e Escalabilidade
+
+- Como a arquitetura é modular, é mais fácil escalar e introduzir novas funcionalidades. Você pode adicionar novos casos de uso sem afetar as outras partes da aplicação.
+- **Exemplo**: Se o sistema bancário precisa de um novo tipo de operação, pode-se simplesmente criar um novo caso de uso sem modificar as entidades ou os adaptadores existentes.
+
+### 5. Resiliência a Mudanças de Requisitos
+
+- Os sistemas projetados com Clean Architecture são menos suscetíveis a mudanças, porque isolam as partes mais voláteis do sistema (UI, frameworks, etc.) das partes mais estáveis (regras de negócios). Isso protege o sistema contra grandes mudanças quando novos requisitos aparecem.
+- **Exemplo**: Se a interface de entrada mudar de uma API para uma interface gráfica, o impacto será mínimo, pois as regras de negócio e os casos de uso já estão encapsulados e prontos para lidar com o novo adaptador.
+
+### 6. Independência de Interface de Usuário
+
+- A lógica de negócio não depende da interface com o usuário, o que permite substituir a UI sem impactar os casos de uso ou as regras de negócio. Isso é útil em cenários onde é necessário criar diferentes interfaces para web, mobile, e desktop.
+- **Exemplo**: Um sistema bancário pode ter uma interface web e um aplicativo mobile, ambos interagindo com os mesmos casos de uso sem duplicar código.
+
+### 7. Flexibilidade no Uso de Bancos de Dados
+
+- Como o banco de dados está abstraído na camada de infraestrutura, você pode trocar de um banco de dados relacional para um banco NoSQL, por exemplo, sem impactar as camadas de negócio.
+- **Exemplo**: Se você começar com um banco de dados MySQL e decidir migrar para MongoDB, a mudança afetará apenas a camada de infraestrutura, sem modificar a lógica de negócio.
+
+### 8. Código mais Limpo e Organizado
+
+- A separação clara entre responsabilidades e camadas de código leva a uma estrutura mais limpa e organizada. Isso também torna o código mais fácil de ler e entender por outros desenvolvedores.
+- **Exemplo**: Um novo desenvolvedor pode rapidamente entender onde as regras de negócios estão localizadas, quais são os casos de uso e como o sistema interage com as partes externas.
+
+## Desafios ao Implementar Clean Architecture
+
+Embora as vantagens sejam muitas, a implementação de Clean Architecture pode trazer alguns desafios:
+
+- **Complexidade Inicial**: Para sistemas pequenos, a implementação inicial pode parecer mais complexa do que necessário. A criação de múltiplas camadas e abstrações pode ser um overhead em projetos simples.
+- **Curva de Aprendizado**: Entender completamente os princípios e aplicá-los corretamente demanda experiência e conhecimento das boas práticas de design de software.
+
+No entanto, em sistemas que demandam manutenção contínua e que podem crescer com o tempo, os benefícios superam os desafios.
+
+## Conclusão
+
+A Clean Architecture oferece um modelo poderoso e flexível para projetar sistemas de software. Ao seguir os princípios dessa arquitetura, você cria aplicações que são independentes de frameworks, altamente testáveis, fáceis de manter e escaláveis. Para projetos complexos e de longo prazo, a aplicação de Clean Architecture garante uma base sólida que resiste a mudanças e facilita a evolução contínua do software.
+
+## Referências
+
+[The Clean Architecture - Ungle Bobo](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)

docs/config/README.md

@@ -6,6 +6,7 @@
 - [DBeaver](https://dbeaver.io/)
 - [Docker](https://www.docker.com/)
 - [GIT](https://git-scm.com/)
+- [K6](https://grafana.com/docs/k6/latest/)
 
 ## PostgreSQL :floppy_disk:
 
@@ -63,7 +64,7 @@ docker run --name tech-challenge -p 5432:5432 -e POSTGRES_PASSWORD=123456 -d pos
 Após a execução dos comandos acima, validar a conectividade através do CLI ou interface visual da sua preferência, aqui
 iremos utilizar o [DBeaver](https://dbeaver.io/).
 
-![image](https://github.com/fiap-8soat-tc-one/tc-backend/blob/main/assets/setup-postgres.png)
+![image](https://github.com/fiap-8soat-tc-one/tc-backend-s2/blob/main/assets/setup-postgres.png)
 
 ## Intellij e JAVA 17 :factory:
 
@@ -125,29 +126,49 @@ sem necessidade de configurações avançadas, além disso em seu kit de ferrame
     - Abra o projeto através da IDE e acesse o caminho `File -> Project Structure`.
     - NA sessão `Plataform Settings -> SDKs` instale o open-jdk 17, segue abaixo a imagem:
 
-   ![image](https://github.com/fiap-8soat-tc-one/tc-backend/blob/main/assets/setup-intellij-jdk.png)
+   ![image](https://github.com/fiap-8soat-tc-one/tc-backend-s2/blob/main/assets/setup-intellij-jdk.png)
 
 3. **Configuração do Maven**
     - Com projeto aberto através da IDE acessar o caminho `Run -> Edit Configuration`
     - Adicionar o seguinte comando maven `mvn clean package`, segue abaixo a imagem:
 
-   ![image](https://github.com/fiap-8soat-tc-one/tc-backend/blob/main/assets/setup-intellij-maven.png)
+   ![image](https://github.com/fiap-8soat-tc-one/tc-backend-s2/blob/main/assets/setup-intellij-maven.png)
 
     - Executar o comando deve apresentar o seguinte resultado
 
-   ![image](https://github.com/fiap-8soat-tc-one/tc-backend/blob/main/assets/setup-intellij-maven-result.png)
+   ![image](https://github.com/fiap-8soat-tc-one/tc-backend-s2/blob/main/assets/setup-intellij-maven-result.png)
 
 4. **Execução da aplicação localmente**
     - Com projeto aberto através da IDE acessar o caminho `Run -> Edit Configuration`
     - Adicionaras seguintes configurações:
 
-   ![image](https://github.com/fiap-8soat-tc-one/tc-backend/blob/main/assets/setup-intellij-app.png)
+   ![image](https://github.com/fiap-8soat-tc-one/tc-backend-s2/blob/main/assets/setup-intellij-app.png)
 
     - Executar a aplicação e o resultado experado deve ser:
 
-   ![image](https://github.com/fiap-8soat-tc-one/tc-backend/blob/main/assets/setup-intellij-maven-result.png)
+   ![image](https://github.com/fiap-8soat-tc-one/tc-backend-s2/blob/main/assets/setup-intellij-maven-result.png)
 
     - **A aplicação está configurada para o flyway gerar as tabelas no PostgreSQL, abra o DBeaver ou a ferramenta da sua
       escolha e confira se as tabelas do sistema foram criadas.**
 
     - Ao executar a aplicação, acessar a url do swagger/open-api `http://localhost:8080/swagger-ui/index.html`
+
+### Grafana K6
+
+O **Grafana k6** é uma ferramenta open-source para testes de carga e desempenho, projetada para simular como uma aplicação se comporta sob alto tráfego. Originalmente chamada apenas de **k6**, após ser adquirida pela Grafana Labs, passou a integrar o ecossistema da Grafana, facilitando a criação, execução e análise de testes de performance. Ele é especialmente utilizado para testar APIs, microsserviços e aplicações web, permitindo que equipes validem a capacidade de suas infraestruturas sob carga.
+
+### Principais vantagens do Grafana k6 em comparação com outras ferramentas:
+
+1. **Integração com o Ecossistema Grafana**: A integração com Grafana permite uma visualização robusta e em tempo real dos resultados de desempenho, possibilitando uma análise mais profunda e rica.
+
+2. **Script em JavaScript**: Os scripts de teste são escritos em JavaScript, uma linguagem amplamente conhecida, o que facilita o aprendizado e a criação de testes personalizados em comparação com outras ferramentas que usam linguagens ou sintaxes mais complexas.
+
+3. **Escalabilidade**: k6 é altamente escalável e pode simular milhares de usuários virtuais sem comprometer o desempenho da máquina de teste, tornando-o uma escolha adequada para testes em larga escala.
+
+4. **Fácil Automação e Integração**: Ele pode ser facilmente integrado em pipelines de CI/CD e automatizado, oferecendo compatibilidade com várias ferramentas de automação.
+
+5. **Baixo Overhead**: Diferente de outras ferramentas que podem consumir muitos recursos da máquina de teste, o k6 tem um overhead baixo, garantindo que a máquina utilizada para o teste não afete os resultados de desempenho.
+
+6. **Modo de Execução Local e Distribuído**: Ele suporta tanto testes locais quanto a execução distribuída na nuvem, o que aumenta a flexibilidade para testar grandes cargas.
+
+Essas características tornam o k6 uma solução poderosa, especialmente para equipes que já utilizam o Grafana para monitoramento e querem uma integração nativa de performance testing na sua stack de observabilidade.

kubernetes/deployment.yaml

@@ -0,0 +1,63 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: app-tc-backend-s2-dep
+  namespace: fiap
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: app-tc-backend-s2
+  template:
+    metadata:
+      labels:
+        app: app-tc-backend-s2
+    spec:
+      containers:
+        - name: app-tc-backend-s2
+          image: 'jcmds/fiap-8soat-tc:latest'
+          ports:
+            - name: http 
+              containerPort: 8080
+              protocol: TCP
+          livenessProbe:
+            httpGet:
+              path: /api/public/v1/health
+              port: 8080
+            failureThreshold: 1
+            periodSeconds: 15           
+          resources:
+            requests:
+              cpu: "200m"
+              memory: "512Mi"
+            limits:
+              cpu: "500m"
+              memory: "1Gi"
+          env:
+            - name: DATABASE_HOST
+              value: db-tc-backends2-fiap.cqjmd1nvleyg.us-east-1.rds.amazonaws.com
+            - name: DATABASE_USER
+              valueFrom:
+                secretKeyRef:
+                  name: credentials-rds
+                  key: username
+            - name: DATABASE_PASS
+              valueFrom:
+                secretKeyRef:
+                  name: credentials-rds
+                  key: password
+            - name: DATABASE_PORT
+              value: "5432"
+            - name: DATABASE_NAME
+              value: postgres
+      restartPolicy: Always
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 25%
+      maxSurge: 25%                 
+
+
+
+
+