Gestione annotazioni versione AWS onprem e su EC2

Author: alnao

.gitignore

@@ -1,3 +1,5 @@
+annotazioni-key.pem
+
 .vscode
 .vscode/settings.json
 

README.md

@@ -16,6 +16,8 @@ Un sistema di gestione annotazioni multi-modulo basato su Spring Boot che implem
 - [🐳 Deploy e utilizzo con DockerHub](#-deploy-e-utilizzo-con-dockerhub)
 - [🐳 Deploy completo con Docker Compose](#-deploy-completo-con-docker-compose)
 - [☸️ Deploy su Minikube (Kubernetes locale)](#️-deploy-su-minikube-kubernetes-locale)
+- [🐳 Deploy AWS-onprem (MySQL e DynamoDB Local)](#-Deploy-AWS-onprem-MySQL-e-DynamoDB-Local)
+- [🚀 Deploy su AWS EC2](#-Deploy-su-AWS-EC2)
 - [📝 Roadmap / TODO](#-todo--roadmap)
 - [🚧 Coming Soon](#-coming-soon)
   - [🔒 Sicurezza](#-sicurezza)
@@ -24,7 +26,6 @@ Un sistema di gestione annotazioni multi-modulo basato su Spring Boot che implem
   - [Deployment AWS ECS/Fargate](#deployment-aws-ecsfargate)
 
 
-
 ## 🛠️ Struttura progetto:
 Il progetto segue i principi dell'*Hexagonal Architecture* (Ports and Adapters) e si basa su un'architettura a microservizi modulare:
 ```
@@ -243,6 +244,10 @@ L'immagine ufficiale dell'applicazione è pubblicata su [DockerHub](https://hub.
     docker build -t alnao/annotazioni:latest .
     docker push alnao/annotazioni:latest
     ```
+    oppure lanciare lo script 
+    ```bash
+    ./script/push-image-docker-hub.sh
+    ```
 - **Pull dell'immagine**:
     ```bash
     docker pull alnao/annotazioni:latest
@@ -399,20 +404,98 @@ L’applicazione e i database posso essere eseguiti anche su Minikube, l’ambie
     - Viene usata l'immagine `alnao/annotazioni:latest` su dockerHub e non una immagine creata in sistema locale.
 
 
+## 🐳 Deploy AWS-onprem (MySQL e DynamoDB Local)
+
+Per simulare l'ambiente AWS in locale (MySQL come RDS, DynamoDB Local, Adminer, DynamoDB Admin UI, Spring Boot profilo AWS):
+- Comando per la creazione dello stack docker
+  ```bash
+  docker-compose -f script/aws-onprem/docker-compose.yml up
+  ```
+  - lo stack crea anche tabelle su Dynamo e tabella MySql
+  - presenta anche uno script `start-all.sh` ma non è necessario usarlo
+- Servizi disponibili:
+  - **Frontend**:        [http://localhost:8085](http://localhost:8085)
+  - **Backend API**:     [http://localhost:8085/api/annotazioni](http://localhost:8085/api/annotazioni)
+  - **Adminer (MySQL)**: [http://localhost:8086](http://localhost:8086)
+    - Server: `mysql`
+    - User: `annotazioni_user`
+    - Password: `annotazioni_pass`
+    - Database: `annotazioni`
+  - **DynamoDB Admin**:  [http://localhost:8087](http://localhost:8087)
+
+- Per prova è stato scritto e poi commentato anche un Nginx/Proxy
+  - Il frontend statico è servito da Nginx su `localhost:8080`.
+  - Le chiamate API `/api/annotazioni` sono automaticamente proxyate verso il backend Spring Boot su `localhost:8085`.
+  - Non è necessario modificare `app.js` o la logica frontend: tutte le chiamate API funzionano come in produzione.
+  - Se modifichi i file statici, riavvia solo il servizio Nginx:
+    ```bash
+    docker-compose restart nginx
+    ```
+    - Se la porta 8080 è occupata, puoi cambiare la porta esposta nel servizio Nginx nel `docker-compose.yml`.
+- Per vedere i log di un servizio:
+  ```bash
+  docker-compose logs -f <nome-servizio>
+  ```
+- Per fermare tutto e rimuovere i componenti:
+  ```bash
+  docker-compose -f script/aws-onprem/docker-compose.yml down
+  ```
+  - presente anche uno script `stop-all.sh`
+
+
+## 🚀 Deploy su AWS EC2
+Questa modalità consente di eseguire l'intero stack annotazioni su AWS EC2, con provisioning completamente automatizzato di tutte le risorse cloud necessarie (Aurora MySQL, DynamoDB, EC2, Security Group, IAM Role, KeyPair, ecc.) tramite script Bash e AWS CLI.
+- Prerequisiti:
+  - AWS CLI installata e configurata (`aws configure`)
+  - Credenziali AWS con permessi minimi per EC2, RDS, DynamoDB, IAM, VPC, KeyPair
+  - Chiave SSH per accesso sicuro all'istanza EC2 (verrà generata se non presente)
+  - Lo script usa la VPC di default di un account e crea il security group necessario
+- Provisioning e deploy automatico:
+  - **Avvia provisioning e deploy**:
+    ```bash
+    ./script/aws-ec2/start-all.sh
+    ```
+    Lo script esegue in sequenza:
+    - Creazione VPC, Security Group, KeyPair, IAM Role
+    - Provisioning Aurora MySQL (RDS) e DynamoDB
+    - Upload e lancio script di inizializzazione SQL su Aurora (init-mysql.sql)
+    - Creazione e configurazione istanza EC2 (Amazon Linux 2)
+    - Deploy automatico del jar Spring Boot e avvio con profilo `aws`
+    - Configurazione variabili d'ambiente e sicurezza SSH
+  - **Accesso all'applicazione**:
+    - L'output finale dello script mostra l'IP pubblico EC2 e la porta applicativa (default 8080)
+    - Accedi da browser: `http://<EC2_PUBLIC_IP>:8080`
+    - Accesso SSH:
+      ```bash
+      ssh -i annotazioni-key.pem ec2-user@<EC2_PUBLIC_IP>
+      ```
+  - **Teardown e cleanup**:
+    Per rimuovere tutte le risorse create (EC2, RDS, DynamoDB, Security Group, KeyPair, ecc):
+    ```bash
+    ./script/aws-ec2/stop-all.sh
+    ```
+- Note
+  - Lo script supporta anche il caricamento dello script SQL da S3 (opzionale, vedi variabile `INIT_SQL_S3_PATH`)
+  - Il provisioning è idempotente: puoi rilanciare lo script senza duplicare risorse
+  - Tutte le risorse sono taggate per facile identificazione e cleanup
+  - Potrebbe avere qualche problema in fase di avvio perchè il database non viene *agganciato* dal microservizio, non so il perchè, ho *ignorato* il problema visto che conviene usare ECS e EKS.
+
+
 ## 📝 TODO / Roadmap
 - ✅ Creazione progetto e primo test con pagina web di esempio
 - ✅ Introduzione modifica nota e documento con vecchie versioni delle note
 - ✅ Configurazione di OpenApi-Swagger e Quality-SonarQube
-- ✅ Build e deploy su DockerHub, configurazione di docker-compose
-- ✅ Run on Minikube
-- 🚧 Test con Mysql e DynamoDB 
-- 🚧 Deploy su AWS su EC2 / Lightsail
+- ✅ Build e deploy su DockerHub, configurazione di docker-compose con MongoDb e Postgresql
+- ✅ Esecuzione su Minikube con yaml dedicati
+- ✅ Esecuzione con docker-compose della versione AWS su sistema locale con Mysql e DynamoDB 
+- ✅ Deploy su AWS su EC2 con script scritto in AWS-CLI per il provisioning delle risorse necessarie
+- 🚧 Storico annotazioni su Dynamo
 - 🚧 Deploy su AWS su Fargate/ECS
 - 🚧 Deploy su AWS su EKS
 - 🚧 Sistema di caching e ottimizzazione
 - 🚧 Sistem di Deploy con Kubernetes Helm charts
-- 🚧 Autenticazione e autorizzazione (Spring Security) e token Jwt
 - 🚧 Gestione multiutente e versioning annotazioni
+- 🚧 Autenticazione e autorizzazione (Spring Security) e token Jwt
 - 🚧 Export/Import annotazioni (JSON, CSV)
 - 🚧 Export/Import annotazioni (Kafka)
 - 🚧 Notifiche real-time (WebSocket)

adapter-aws/src/main/java/it/alnao/annotazioni/aws/config/AwsConfiguration.java

@@ -1,11 +1,15 @@
 package it.alnao.annotazioni.aws.config;
 
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.domain.EntityScan;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Profile;
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
 import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
 import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
@@ -16,12 +20,36 @@
 @EntityScan(basePackages = "it.alnao.annotazioni.aws.entity")
 public class AwsConfiguration {
 
+    @Value("${AWS_REGION:eu-central-1}")
+    private String awsRegion;
+
+    @Value("${AWS_ACCESS_KEY_ID:dummy}")
+    private String awsAccessKeyId;
+
+    @Value("${AWS_SECRET_ACCESS_KEY:dummy}")
+    private String awsSecretAccessKey;
+
+    @Value("${DYNAMODB_ENDPOINT:}")
+    private String dynamodbEndpoint;
+
     @Bean
     public DynamoDbClient dynamoDbClient() {
+        AwsCredentialsProvider credentialsProvider;
+        if (awsAccessKeyId != null && !awsAccessKeyId.equals("") && awsSecretAccessKey != null && !awsSecretAccessKey.equals("")) {
+            credentialsProvider = StaticCredentialsProvider.create(AwsBasicCredentials.create(awsAccessKeyId, awsSecretAccessKey));
+        } else {
+            credentialsProvider = DefaultCredentialsProvider.create();
+        }
+        // Build the client directly, chaining methods, without declaring a Builder variable
         return DynamoDbClient.builder()
-                .region(Region.US_EAST_1) // Configurabile via application.yml
-                .credentialsProvider(DefaultCredentialsProvider.create())
-                .build();
+            .region(Region.of(awsRegion))
+            .credentialsProvider(credentialsProvider)
+            .applyMutation(b -> {
+                if (dynamodbEndpoint != null && !dynamodbEndpoint.isEmpty()) {
+                    b.endpointOverride(java.net.URI.create(dynamodbEndpoint));
+                }
+            })
+            .build();
     }
 
     @Bean

adapter-aws/src/main/java/it/alnao/annotazioni/aws/entity/AnnotazioneStoricoDynamoEntity.java

@@ -1,7 +1,10 @@
 package it.alnao.annotazioni.aws.entity;
 
+import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;
+import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;
 import java.time.LocalDateTime;
 
+@DynamoDbBean
 public class AnnotazioneStoricoDynamoEntity {
     private String id;
     private String idOriginale;
@@ -15,7 +18,7 @@ public class AnnotazioneStoricoDynamoEntity {
     private Integer priorita;
     private LocalDateTime dataModifica;
 
-    // Getters and Setters
+    @DynamoDbPartitionKey
     public String getId() { return id; }
     public void setId(String id) { this.id = id; }
     public String getIdOriginale() { return idOriginale; }

adapter-aws/src/main/java/it/alnao/annotazioni/aws/repository/AnnotazioneStoricoDynamoRepositoryDdbImpl.java

@@ -0,0 +1,43 @@
+package it.alnao.annotazioni.aws.repository;
+
+import it.alnao.annotazioni.aws.entity.AnnotazioneStoricoDynamoEntity;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Repository;
+import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
+import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
+import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
+import software.amazon.awssdk.enhanced.dynamodb.model.PageIterable;
+import software.amazon.awssdk.enhanced.dynamodb.model.ScanEnhancedRequest;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Repository
+@Profile("aws")
+public class AnnotazioneStoricoDynamoRepositoryDdbImpl implements AnnotazioneStoricoDynamoRepository {
+    private final DynamoDbTable<AnnotazioneStoricoDynamoEntity> table;
+
+    @Autowired
+    public AnnotazioneStoricoDynamoRepositoryDdbImpl(DynamoDbEnhancedClient dynamoDbEnhancedClient) {
+        this.table = dynamoDbEnhancedClient.table("annotazioni_storico", TableSchema.fromBean(AnnotazioneStoricoDynamoEntity.class));
+    }
+
+    @Override
+    public AnnotazioneStoricoDynamoEntity save(AnnotazioneStoricoDynamoEntity entity) {
+        if (entity.getId() == null || entity.getId().isEmpty()) {
+            entity.setId(java.util.UUID.randomUUID().toString());
+        }
+        table.putItem(entity);
+        return entity;
+    }
+
+    @Override
+    public List<AnnotazioneStoricoDynamoEntity> findByIdOriginale(String idOriginale) {
+        // DynamoDB non supporta query su attributi non chiave senza GSI, quindi si fa scan e filtro in memoria
+        PageIterable<AnnotazioneStoricoDynamoEntity> results = table.scan(ScanEnhancedRequest.builder().build());
+        return results.items().stream()
+                .filter(e -> idOriginale.equals(e.getIdOriginale()))
+                .collect(Collectors.toList());
+    }
+}