Pubblicato il 21/05/2023 da alnao nella categoria AWS

Il servizio di bilanciamento e distribuzione del traffico tra applicazioni è gestito dal servizio Ellastic Load Balancing e mette a disposizione quattro tipi di bilanciamento:

  • Application Load Balancer: il tipo più usato perchè è il bilancamento viene eseguito a livelli 7 cioè a livello di protocollo HTTP o di altro tipo applicativo
  • Network Load Balancer: il tipo di bilanciamento a livello 4 cioè usando il protocollo TPC o UDP
  • Gateway Load Balancer: il tipo di bilanciamento a livello 3 cioè usando il solo protocollo IP
  • Classic Load Balancer: il tipo originale di AWS, considerato deprecato in quanto sostituito con i precedenti

In fase di creazione di un bilanciatore si devono selezionare i parametri

  • il tipo (application, network oppure gateway)
  • esposizione internet, nel caso venga abilitata sarà creata un nome con il quale è possibile accedervi da internet
  • VPN, subnet e AZ, infatti è possibile posizionare il bilanciatore nelle subnet private ma con la precedente regola avere un entry-point pubblico
  • security group per regolare il traffico in ingresso ed in uscita
  • l’eventuale AutoScaling group e il “target group” se presenti

Il servizio è molto usato sia per creare degli entry-point pubblici a risorse private ed è studiato proprio per integratsi con il servizio di AutoScaling e creare un unico enpoint per tutte le istanze appartenenti ad un gruppo creato con il servizio di AutoScaling e poi gestite come “target group” dal servizio.

Il bilanciatore crea una “specie” di Firewall e proxy con i quale è possibile regolare alcune regole di rete tra cui il protocollo SSL/TLS, regole di redirect anche se è sempre consigliato usare un WAF come strumento per le regole di traffico di rete. I costi del servizio variano dal tipo e dalla region di appartenenza, per esempio l’Application in Irlanda costa 0,0252 USD per ora, bisogna comunque sempre monitorare i costi, le varie tariffe sono disponibili nella pagina ufficiale.

Pubblicato il 13/05/2023 da alnao nella categoria AWS

Il servizio di Autoscaling delle EC2 di AWS permette di monitorare il numero di istanze applicative regolando automaticamente l’aumento o la diminuzione in base a dei criteri prefissati. Il caso d’uso più diffuso e usato è la creazione di una immagine AMI e poi l’avvio di più istanze EC2, il numero di istanze viene regolato da una regola di scalabilità in base alla CPU o altre metriche. 

In fase di creazione da console si deve selezionare:

  • il nome che permetterà di identificare il gruppo anche nella vista EC2: le istanze appartanenti ad un gruppo ottengono il tag di quel gruppo
  • la regola di “launch configuration” con la quale si gestire la regola di creazione delle istanze
  • la VPC e le AZ associate se sono disponibili subnet
  • il load balancer associato a questo gruppo per permettere l’accesso e il bilanciamento, è possibile non selezionare nulla
  • la verifica di “health check”, cioè la regola che verifica il corretto funzionamento delle istanze, in quanto eventuali istanze con problemi vengono distrutte e vengono sostituite
  • le dimensioni del gruppo con l’impostazione del numero minimo, massimo e il desiderato
  • eventuali notifiche in caso di modifica del gruppo tramite il servizio SNS

Da notare che in fase di creazione non vengono richieste alcune proprietà importanti che devono essere impostate nel “launch configuration”, per esempio

  • la immagine AMI ufficiale o una AMI gestita e creata dall’utente nello store
  • il tipo di istanze in quanto all’interno di gruppo tutte le istanze devono avere la stessa dimensione
  • la chiave “key pair” gestita da KMS per permette la connessione remota
  • il security group che verrà assegnato ad ogni istanza (da notare che senza regole specifiche le istanze non potranno comunicare tra di loro)

Nel dettaglio di un gruppo è possibile gestire

  • gli eventi passati del gruppo con uno storico dettagliato
  • le regole di scalabilità automatica
  • gestione delle singole istanze con i dettagli
  • la procedura di refresh di tutte le istanze

La documentazione ufficiale è molto dettagliata visto che questo è uno dei servizi più usati. Il servizio è gratuito ma bisogna sempre ricordare che tutte le istanze EC2 sottostanti sono ovviamente a pagamento quindi bisogna sempre prestare attenzione.

Pubblicato il 06/05/2023 da alnao nella categoria AWS

Una delle applicazioni più usate di CluodFormation è creare sistemi applicativi in reti private ma esposte in internet con un Application Load Balancer che permette anche di creare un Autoscaling group per garantire la resilienza e la scalabilità della stessa applicazione. Usando CloudFormation è possibile disegnare e creare tutta l’architettura che comprende:

  • VPC con subnet private e pubbliche
  • VPC endpoint per accedere via client alla rete
  • Database applicativo con il servizio RDS
  • LoadBalancer per bilanciare il traffico e creare un endpoint pubblico
  • TargetGroup e AutoScalingGroup per gestire le istanze applicative e le regole di scalabilità
  • LaunchConfiguration per creare le regole di avvio delle istanze

In un semplice esempio è possibile installare l’applicativo WordPress e il server Apache usando l’userData e le ConfigSet previste dal servizio EC2, in questo modo è possibile gestire tutto in autonomia in modo da permettere che ogni istanza avvii l’applicazione indipendente che punta alla stessa base dati (RDS) ma vive di vita proprio. L’esempio completo è disponibile al solito repository:

https://github.com/alnao/AWSCloudFormationExamples/tree/master/Esempio25balancer

Questo esempio presenta dei difetti strutturali: ogni istanza è isolata e non c’è un filesystem condiviso, framework o applicazioni che necessitano storage condiviso non funziona, per esempio un sito WordPress in questo modo non funzionerebbe perché i media sarebbero storicizzati in una istanza e le altre non vedrebbero i files delle altre istanze, per risolvere il problema si può usare un disco EFS condiviso, template che sarà esposto nel prossimo esempio. 

Pubblicato il 29/04/2023 da alnao nella categoria AWS, Java EE

Un semplicissimo ma utile esempio di sviluppo con la piattaforma SDK di AWS in Java è la realizzazione di un piccolo programma per la creazione ed la distruzione di un bucket S3. Questo semplice esempio è stato costruito studiando la documentazione ufficiale  e gli esempi presenti nel repository ufficiale.

In questo esempio vengono definiti tre metodi per la creazione, la canncellazione e la verifica dell’esistenza di un bucket S3. Si basano sul client S3 del SDK che deve essere creata con i comandi:

ProfileCredentialsProvider credentialsProvider = 
ProfileCredentialsProvider.create();
Region region = Region.EU_WEST_1;
S3Client s3 = S3Client.builder().region(region)
.credentialsProvider(credentialsProvider).build();

Poi un semplice metodo per la creazione di un bucket è

public static void createBucket( S3Client s3Client, String bucketName) {
try {
CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
.bucket(bucketName).build();
s3Client.createBucket(bucketRequest);
// Wait until the bucket is created and print out the response.
HeadBucketRequest bucketRequestWait = HeadBucketRequest.builder()
.bucket(bucketName).build();
S3Waiter s3Waiter = s3Client.waiter();
WaiterResponse<HeadBucketResponse> waiterResponse = s3Waiter
.waitUntilBucketExists(bucketRequestWait);
//waiterResponse.matched().response().ifPresent(System.out::println);
logger.info(bucketName +" is ready");
} catch (S3Exception e) {
System.err.println("Errore: " + e.awsErrorDetails().errorMessage());
return;
}
}

La relativa test-unit definisce un semplice metodo che crea il bucket e ne verifica l’esistenza con un secondo metodo

@Test
@Order(2)
public void createBucket() {
System.out.println("Test 2 createBucket started");
App.createBucket(s3,bucketName);
boolean result=App.checkIfBucketExist(s3,bucketName);
assertTrue(result);
System.out.println("Test 2 createBucket passed");
}

Il metodo dell’esistenza del bucket può essere sempre definito nella classe principale, basta infatti andare a scaricare l’elenco dei bucket esistenti e fare una ricarca del nome

public static boolean checkIfBucketExist( S3Client s3Client, String bucketName) {
logger.info(bucketName +" checkIfBucketExist");
ListBucketsRequest listBucketsRequest = ListBucketsRequest.builder().build();
ListBucketsResponse listBucketsResponse = s3Client.listBuckets(listBucketsRequest);
boolean exist=false;
Iterator<Bucket> it=listBucketsResponse.buckets().iterator();
while(it.hasNext()) {
Bucket b=it.next();
if (b.name().equals(bucketName))
exist=true;
}
logger.info(bucketName +" checkIfBucketExist " + (exist ? "YES" : "NO" ) );
return exist;
}

Questo esempio completo e funzionante è disponibile al repository

https://github.com/alnao/JavaExamples/tree/master/AwsSdkJava/01_CreateBucket