Tutorial - GlassFish su Docker: percorso verso Amazon Linux 2023

GlassFish Contenitori Docker preconfigurati su Elastic Beanstalk

Nota

Il 18 luglio 2022, Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux () come ritirato. AMI AL1 Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2.

Il ramo della GlassFish piattaforma Docker preconfigurato che funziona su Amazon Linux AMI (AL1) non è più supportato. Per migrare la tua GlassFish applicazione su una piattaforma Amazon Linux 2023 supportata, distribuisci GlassFish e il codice dell'applicazione su un'immagine Docker Amazon Linux 2023. Per ulteriori informazioni, consulta l'argomento seguente, Distribuzione di un' GlassFish applicazione sulla piattaforma Docker: un percorso di migrazione verso Amazon Linux 2023.

Questa sezione descrive come sviluppare un'applicazione di esempio in locale, quindi distribuire l'applicazione in Elastic Beanstalk con un container Docker preconfigurato.

Configurazione dell'ambiente di sviluppo locale

Per questa procedura dettagliata utilizziamo un'applicazione di esempio. GlassFish

Come configurare l'ambiente

Crea una nuova cartella per l'applicazione di esempio.


~$ mkdir eb-preconf-example
~$ cd eb-preconf-example

Scarica il codice dell'applicazione di esempio nella nuova cartella.


~$ wget https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/samples/docker-glassfish-v1.zip
~$ unzip docker-glassfish-v1.zip
~$ rm docker-glassfish-v1.zip

Sviluppo e test in locale

Per sviluppare un'applicazione di esempio GlassFish

Aggiungi un Dockerfile alla cartella principale dell'applicazione. Nel file, specifica l'immagine di base AWS Elastic Beanstalk Docker da utilizzare per eseguire il contenitore Docker preconfigurato locale. Successivamente distribuirai l'applicazione su una versione della piattaforma Docker preconfigurata Elastic GlassFish Beanstalk. Scegli l'immagine di base del Docker che si avvale di questa versione. Per individuare l'immagine Docker corrente della versione della piattaforma, consulta la sezione Docker preconfigurato nella pagina Piattaforme AWS Elastic Beanstalk supportate nella guida Piattaforme AWS Elastic Beanstalk .
Esempio b-preconf-example~/E /Dockerfile
```
# For Glassfish 5.0 Java 8
FROM amazon/aws-eb-glassfish:5.0-al-onbuild-2.11.1
```
Per ulteriori informazioni sull'utilizzo di un Dockerfile, consulta Preparazione dell'immagine Docker per la distribuzione su Elastic Beanstalk.

Creazione dell'immagine Docker.


~/eb-preconf-example$ docker build -t my-app-image .

Esegui il container Docker dall'immagine.

Nota
Devi includere il flag -p per mappare la porta 8080 sul container alla porta 3000 del localhost. I container Docker Elastic Beanstalk espongono sempre l'applicazione sulla porta 8080 del container. I flag -it eseguono l'immagine come processo interattivo. Il flag --rm svuota il file system del container quando il container esce. Opzionalmente puoi includere il flag -d per eseguire l'immagine come un daemon.
```
$ docker run -it --rm -p 3000:8080 my-app-image
```
Per visualizzare l'applicazione di esempio, digita quanto segue URL nel tuo browser web.
```
http://localhost:3000
```

Distribuzione in Elastic Beanstalk

Dopo aver testato l'applicazione, puoi distribuirla su Elastic Beanstalk.

Per distribuire l'applicazione su Elastic Beanstalk

Nella cartella principale dell'applicazione rinomina Dockerfile in Dockerfile.local. Questo passaggio è necessario affinché Elastic Beanstalk Dockerfile utilizzi il che contiene le istruzioni corrette per Elastic Beanstalk per creare un'immagine Docker personalizzata su ogni istanza Amazon nel tuo ambiente Elastic Beanstalk. EC2

Nota
Non è necessario eseguire questa operazione se Dockerfile include le istruzioni che modificano l'immagine Docker di base della versione della piattaforma. Non è necessario utilizzare un Dockerfile se tutto il Dockerfile include solo una riga FROM per specificare l'immagine di base da cui creare il container. In tal caso, il Dockerfile è ridondante.
Crea un bundle di origine dell'applicazione.
```
~/eb-preconf-example$ zip myapp.zip -r *
```
Apri la console Elastic Beanstalk con questo link preconfigurato: console.aws.amazon.com/elasticbeanstalk/home#/? newApplication applicationNameenvironmentType=tutoriali& = LoadBalanced
In Platform (Piattaforma), in Preconfigured – Docker (Preconfigurata - Docker) scegli Glassfish.
Per Application code (Codice applicazione), selezionare Upload your code (Carica il tuo codice), quindi Upload (Carica).
Scegliere Local file (File locale), selezionare Browse (Sfoglia), quindi per aprir e quindi operare il bundle risorsa dell'applicazione appena creato.
Scegli Carica.
Selezionare Review and launch (Controlla e avvia).
Controlla le impostazioni disponibili, quindi seleziona Create app (Crea applicazione).
Quando l'ambiente viene creato, è possibile visualizzare l'applicazione distribuita. Scegli l'ambiente URL visualizzato nella parte superiore della dashboard della console.

Distribuzione di un' GlassFish applicazione sulla piattaforma Docker: un percorso di migrazione verso Amazon Linux 2023

L'obiettivo di questo tutorial è fornire ai clienti che utilizzano la GlassFish piattaforma Docker preconfigurata (basata su Amazon LinuxAMI) un percorso di migrazione verso Amazon Linux 2023. Puoi migrare la tua GlassFish applicazione su Amazon Linux 2023 distribuendo GlassFish e il codice dell'applicazione su un'immagine Docker Amazon Linux 2023.

Il tutorial illustra come utilizzare la piattaforma AWS Elastic Beanstalk Docker per distribuire un'applicazione basata sull' GlassFish application server Java EE in un ambiente Elastic Beanstalk.

Dimostriamo due approcci alla creazione di un'immagine Docker:

Semplice: fornisci il codice sorgente GlassFish dell'applicazione e consenti a Elastic Beanstalk di creare ed eseguire un'immagine Docker come parte del provisioning del tuo ambiente. È facile da configurare, con un costo maggiore del tempo di provisioning delle istanze.
Advanced (Avanzato): crea un'immagine Docker personalizzata contenente il codice dell'applicazione e le dipendenze, quindi forniscila a Elastic Beanstalk affinché venga usata nell'ambiente. Questo approccio è leggermente più coinvolto e riduce il tempo di provisioning delle istanze nell'ambiente.

Prerequisiti

Questo tutorial presuppone che tu abbia una certa conoscenza delle operazioni di base di Elastic Beanstalk, dell'interfaccia a riga di comando (EB) di Elastic Beanstalk e di Docker. CLI Se non lo hai già fatto, segui le istruzioni in Guida introduttiva a Elastic Beanstalk per avviare il tuo primo ambiente Elastic Beanstalk. Questo tutorial utilizza l'EB CLI, ma puoi anche creare ambienti e caricare applicazioni utilizzando la console Elastic Beanstalk.

Per completare questo tutorial, sono necessari anche i seguenti componenti Docker:

Un'installazione locale funzionante di Docker. Per ulteriori informazioni, consulta Ottieni Docker sul sito Web della documentazione di Docker.
Accedi a Docker Hub. Sarà necessario creare un ID Docker per accedere a Docker Hub. Per ulteriori informazioni, consulta Condividere l'applicazione sul sito Web della documentazione di Docker.

Per ulteriori informazioni sulla configurazione di ambienti Docker sulle piattaforme Elastic Beanstalk, consulta Preparazione dell'immagine Docker per la distribuzione su Elastic Beanstalk in questo stesso capitolo.

Esempio semplice: fornisci il codice dell'applicazione

Questo è un modo semplice per distribuire la tua applicazione. GlassFish Fornisci il codice sorgente dell'applicazione insieme al file Dockerfile incluso in questo tutorial. Elastic Beanstalk crea un'immagine Docker che include l'applicazione e lo stack software. GlassFish Elastic Beanstalk esegue quindi l'immagine sulle istanze dell'ambiente.

Un problema con questo approccio è che Elastic Beanstalk crea l'immagine Docker in locale ogni volta che crea un'istanza per l'ambiente. La generazione dell'immagine aumenta il tempo di provisioning dell'istanza. Questo impatto non si limita alla creazione iniziale dell'ambiente, ma si verifica anche durante le operazioni di scalabilità orizzontale.

Per avviare un ambiente con un'applicazione di esempio GlassFish

Scaricare l'esempio docker-glassfish-al2-v1.zip, quindi espandere il .zip file in una directory nell'ambiente di sviluppo.
```
~$ curl https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/samples/docker-glassfish-al2-v1.zip --output docker-glassfish-al2-v1.zip
~$ mkdir glassfish-example
~$ cd glassfish-example
~/glassfish-example$ unzip ../docker-glassfish-al2-v1.zip
```
La struttura della directory dovrebbe essere la seguente.
```
~/glassfish-example
|-- Dockerfile
|-- Dockerrun.aws.json
|-- glassfish-start.sh
|-- index.jsp
|-- META-INF
|   |-- LICENSE.txt
|   |-- MANIFEST.MF
|   `-- NOTICE.txt
|-- robots.txt
`-- WEB-INF
    `-- web.xml
```
I seguenti file sono fondamentali per creare ed eseguire un container Docker nel proprio ambiente:
- Dockerfile: fornisce istruzioni utilizzate da Docker per creare un'immagine con l'applicazione e le dipendenze richieste.
- glassfish-start.sh: uno script di shell eseguito dall'immagine Docker per avviare l'applicazione.
- Dockerrun.aws.json— Fornisce una chiave di registrazione, per includere le richieste dei file di registro del server delle GlassFish applicazioni. Se non siete interessati ai GlassFish log, potete omettere questo file.
Configura la directory locale per la distribuzione su Elastic Beanstalk.
```
~/glassfish-example$ eb init -p docker glassfish-example
```
(Facoltativo) Utilizza il comando eb local run per creare ed eseguire il tuo container in locale.
```
~/glassfish-example$ eb local run --port 8080
```
Nota
Per ulteriori informazioni sul comando eb local, consulta eb local. Il comando non è supportato da Windows. In alternativa, è possibile creare ed eseguire il container con i comandi docker build e docker run. Per ulteriori informazioni, consulta la documentazione Docker.
(Facoltativo) Mentre il tuo container è in esecuzione, utilizza il comando eb local open per visualizzare l'applicazione in un browser Web. In alternativa, apri http://localhost:8080/ in un browser Web.
```
~/glassfish-example$ eb local open
```
Utilizza il comando eb create per creare un ambiente e distribuire l'applicazione.
```
~/glassfish-example$ eb create glassfish-example-env
```
Dopo l'avvio dell'ambiente, utilizzare il comando eb open per visualizzarlo in un browser Web.
```
~/glassfish-example$ eb open
```

Al termine dell'utilizzo dell'esempio, terminare l'ambiente ed eliminare le risorse correlate.


~/glassfish-example$ eb terminate --all

Esempio avanzato: fornire un'immagine Docker precompilata

Si tratta di un modo più avanzato per distribuire l'applicazione. GlassFish Basandoti sul primo esempio, crei un'immagine Docker contenente il codice dell'applicazione e lo stack GlassFish software e la invii a Docker Hub. Dopo aver eseguito questo passaggio una tantum, è possibile avviare ambienti Elastic Beanstalk basati sull'immagine personalizzata.

Quando si avvia un ambiente e si fornisce l'immagine Docker, le istanze dell'ambiente scaricano e utilizzano direttamente questa immagine e non è necessario creare un'immagine Docker. Di conseguenza, il tempo di provisioning dell'istanza viene ridotto.

Note

I seguenti passaggi creano un'immagine Docker disponibile pubblicamente.
Dovrai utilizzare i comandi Docker dell'installazione Docker locale, insieme alle credenziali di Docker Hub. Per ulteriori informazioni, vedere la precedente sezione Prerequisiti in questo argomento.

Per avviare un ambiente con un'immagine Docker dell'applicazione predefinita GlassFish

Scaricare ed espandere l'esempio docker-glassfish-al2-v1.zip come nel precedente esempio semplice. Se hai completato l'esempio, puoi usare la directory che hai già.
Crea un'immagine Docker e spingila su Docker Hub. Inserisci il tuo ID Docker per docker-id per accedere a Docker Hub.
```
~/glassfish-example$ docker build -t docker-id/beanstalk-glassfish-example:latest .
~/glassfish-example$ docker push docker-id/beanstalk-glassfish-example:latest
```
Nota
Prima di eseguire il push dell'immagine, potrebbe essere necessario eseguire docker login. Se si esegue il comando senza parametri, verrà richiesto di specificare le credenziali di Docker Hub.

Creare una directory aggiuntiva.


~$ mkdir glassfish-prebuilt
~$ cd glassfish-prebuilt

Copiare l'esempio seguente in un file denominato Dockerrun.aws.json.

Esempio `~/glassfish-prebuilt/Dockerrun.aws.json`


{
  "AWSEBDockerrunVersion": "1",
  "Image": {
    "Name": "docker-username/beanstalk-glassfish-example"
  },
  "Ports": [
    {
      "ContainerPort": 8080,
      "HostPort": 8080
    }
  ],
  "Logging": "/usr/local/glassfish5/glassfish/domains/domain1/logs"
}

Configura la directory locale per la distribuzione su Elastic Beanstalk.
```
~/glassfish-prebuilt$ eb init -p docker glassfish-prebuilt$
```
(Facoltativo) Utilizzare il eb local run comando per eseguire il container in locale.
```
~/glassfish-prebuilt$ eb local run --port 8080
```
(Facoltativo) Mentre il tuo container è in esecuzione, utilizza il comando eb local open per visualizzare l'applicazione in un browser Web. In alternativa, apri http://localhost:8080/ in un browser Web.
```
~/glassfish-prebuilt$ eb local open
```
Utilizzare il eb create comando per creare un ambiente e distribuire l'immagine Docker.
```
~/glassfish-prebuilt$ eb create glassfish-prebuilt-env
```
Dopo l'avvio dell'ambiente, utilizzare il comando eb open per visualizzarlo in un browser Web.
```
~/glassfish-prebuilt$ eb open
```

Al termine dell'utilizzo dell'esempio, terminare l'ambiente ed eliminare le risorse correlate.


~/glassfish-prebuilt$ eb terminate --all

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

(Legacy) Migrazione a Docker in esecuzione su Amazon Linux 2

Utilizzo di Go

GlassFish Contenitori Docker preconfigurati su Elastic Beanstalk

Nota

Configurazione dell'ambiente di sviluppo locale

Come configurare l'ambiente

Sviluppo e test in locale

Per sviluppare un'applicazione di esempio GlassFish

Esempio b-preconf-example~/E /Dockerfile

Nota

Distribuzione in Elastic Beanstalk

Per distribuire l'applicazione su Elastic Beanstalk

Nota

Distribuzione di un' GlassFish applicazione sulla piattaforma Docker: un percorso di migrazione verso Amazon Linux 2023

Prerequisiti

Esempio semplice: fornisci il codice dell'applicazione

Per avviare un ambiente con un'applicazione di esempio GlassFish

Nota

Esempio avanzato: fornire un'immagine Docker precompilata

Note

Per avviare un ambiente con un'immagine Docker dell'applicazione predefinita GlassFish

Nota

Esempio ~/glassfish-prebuilt/Dockerrun.aws.json

Esempio `~/glassfish-prebuilt/Dockerrun.aws.json`