As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # GlassFish Contêineres Docker pré-configurados no Elastic Beanstalk **nota** [Em 18 de julho de 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **o Elastic Beanstalk definiu o status de todas as ramificações da plataforma baseadas no Amazon Linux AMI AL1 () como descontinuadas.** Para obter mais informações sobre como migrar para uma ramificação da plataforma Amazon Linux 2023 atual e totalmente compatível, consulte [Migrar a aplicação Linux do Elastic Beanstalk para o Amazon Linux 2023 ou Amazon Linux 2](using-features.migration-al.md). A ramificação pré-configurada da GlassFish plataforma Docker que é executada no Amazon Linux AMI (AL1) não é mais suportada. Para migrar seu GlassFish aplicativo para uma plataforma Amazon Linux 2023 compatível, implante GlassFish e seu código de aplicativo em uma imagem Docker do Amazon Linux 2023. Para obter mais informações, consulte o tópico a seguir, [Implantação de um GlassFish aplicativo na plataforma Docker: um caminho de migração para o Amazon Linux 2023](#docker-glassfish-tutorial). ## Primeiros passos com contêineres do Docker pré-configurados no Amazon Linux AMI (anterior ao Amazon Linux 2) Esta seção mostra como desenvolver uma aplicação demonstrativa localmente e implantá-la no Elastic Beanstalk com um contêiner pré-configurado do Docker. ### Configurar seu ambiente de desenvolvimento local Para este passo a passo, usamos um aplicativo de GlassFish exemplo. **Para configurar seu ambiente** 1. Crie uma pasta para o aplicativo de exemplo. ``` ~$ mkdir eb-preconf-example ~$ cd eb-preconf-example ``` 1. Faça o download do código de aplicativo de exemplo para a nova pasta. ``` ~$ wget https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/samples/docker-glassfish-v1.zip ~$ unzip docker-glassfish-v1.zip ~$ rm docker-glassfish-v1.zip ``` ### Desenvolver e testar localmente **Para desenvolver um GlassFish aplicativo de exemplo** 1. Adicione um `Dockerfile` à pasta raiz do seu aplicativo. No arquivo, especifique a imagem base do AWS Elastic Beanstalk Docker a ser usada para executar seu contêiner Docker pré-configurado local. Posteriormente, você implantará seu aplicativo em uma versão pré-configurada da plataforma Docker do Elastic GlassFish Beanstalk. Escolha a imagem de base do Docker que essa versão da plataforma usa. Para descobrir a imagem do Docker atual da versão da plataforma, consulte a seção [Docker pré-configurado](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.dockerpreconfig) na página *Plataformas compatíveis com o AWS Elastic Beanstalk * no guia de *Plataformas do AWS Elastic Beanstalk *. **Example \~/E/Dockerfile b-preconf-example** ``` # For Glassfish 5.0 Java 8 FROM amazon/aws-eb-glassfish:5.0-al-onbuild-2.11.1 ``` Para obter mais informações sobre como usar um `Dockerfile`, consulte [Preparar a imagem do Docker para implantação no Elastic Beanstalk](single-container-docker-configuration.md). 1. Crie a imagem do Docker. ``` ~/eb-preconf-example$ docker build -t my-app-image . ``` 1. Execute o contêiner Docker da imagem. **nota** Você deve incluir o sinalizador `-p` para mapear a porta 8080 no contêiner para a porta 3000 do localhost. Os contêineres do Docker do Elastic Beanstalk sempre expõem a aplicação na porta 8080 no contêiner. O sinalizador `-it` executa a imagem como processo interativo. O sinalizador `--rm` limpa o sistema de arquivos do contêiner quando o contêiner é encerrado. Você tem a opção de incluir o sinalizador `-d` para executar a imagem como um daemon. ``` $ docker run -it --rm -p 3000:8080 my-app-image ``` 1. Para visualizar o aplicativo de exemplo, digite o seguinte URL no seu navegador da web. ``` http://localhost:3000 ``` ![O aplicativo de GlassFish exemplo exibido em um navegador da web](http://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/images/dockerpreconfig-webpage.png) ### Implantar no Elastic Beanstalk Depois de testar a aplicação, você estará pronto para implantá-la no Elastic Beanstalk. **Como implantar a aplicação no Elastic Beanstalk** 1. Na pasta raiz do seu aplicativo, renomeie o `Dockerfile` como `Dockerfile.local`. Essa etapa é necessária para que o Elastic Beanstalk use o `Dockerfile` que contém as instruções corretas para que o Elastic Beanstalk crie uma imagem do Docker personalizada em cada instância do Amazon EC2 no ambiente do Elastic Beanstalk. **nota** Não será necessário executar essa etapa se o `Dockerfile` incluir instruções que modifiquem a imagem de base do Docker da versão da plataforma. Não será necessário usar um `Dockerfile` se o seu `Dockerfile` incluir apenas uma linha `FROM` para especificar a imagem de base da qual criar o contêiner. Neste caso, o `Dockerfile` é redundante. 1. Crie um pacote de origem do aplicativo. ``` ~/eb-preconf-example$ zip myapp.zip -r * ``` 1. [Abra o console do Elastic Beanstalk com este link pré-configurado: console.aws.amazon. com/elasticbeanstalk/home\#/newApplication? Nome do aplicativo = Tutoriais](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced) e tipo de ambiente = LoadBalanced 1. Em **Platform (Plataforma)**, em **Preconfigured – Docker (Pré-configurado - Docker)**, escolha **Glassfish**. 1. Para **Application code**, escolha **Upload your code** e **Upload**. 1. Escolha **Local file (Arquivo local)**, selecione **Browse (Procurar)** e abra o pacote de origem do aplicativo que você acabou de criar. 1. Escolha **Carregar**. 1. Selecione **Review and launch**. 1. Revise as configurações disponíveis e, em seguida, escolha **Create app**. 1. Quando o ambiente é criado, você pode visualizar o aplicativo implantado. Escolha o URL do ambiente exibido na parte superior do painel do console. ## Implantação de um GlassFish aplicativo na plataforma Docker: um caminho de migração para o Amazon Linux 2023 O objetivo deste tutorial é fornecer aos clientes que usam a GlassFish plataforma Docker pré-configurada (baseada no Amazon Linux AMI) um caminho de migração para o Amazon Linux 2023. Você pode migrar seu GlassFish aplicativo para o Amazon Linux 2023 implantando seu código GlassFish de aplicativo em uma imagem Docker do Amazon Linux 2023. O tutorial explica como usar a plataforma AWS Elastic Beanstalk Docker para implantar um aplicativo baseado no [servidor de aplicativos Java EE em um ambiente do GlassFish Elastic](https://www.oracle.com/middleware/technologies/glassfish-server.html) Beanstalk. Demonstramos duas abordagens para criar uma imagem do Docker: + **Simples** — forneça o código-fonte do seu GlassFish aplicativo e deixe o Elastic Beanstalk criar e executar uma imagem do Docker como parte do provisionamento do seu ambiente. Isso é fácil de configurar e tem um custo de maior tempo de provisionamento de instâncias. + **Avançado**: crie uma imagem do Docker personalizada que tenha o código da aplicação e as dependências e forneça-a para o Elastic Beanstalk para uso no ambiente. Essa abordagem é um pouco mais envolvida e diminui o tempo de provisionamento de instâncias em seu ambiente. ### Pré-requisitos Este tutorial pressupõe que você tenha algum conhecimento das operações básicas do Elastic Beanstalk, da Elastic Beanstalk Command Line Interface (EB CLI) e do Docker. Caso ainda não tenha, siga as instruções em [Saiba como começar a usar o Elastic Beanstalk](GettingStarted.md) para iniciar seu primeiro ambiente do Elastic Beanstalk. Este tutorial usa a [EB CLI](eb-cli3.md), mas também é possível criar ambientes e fazer upload de aplicações usando o console do Elastic Beanstalk. Para concluir este tutorial, você precisará fazer o seguinte: + Uma instalação local de trabalho do Docker. Para obter mais informações, consulte [Obter o Docker](https://docs.docker.com/install/) no site de documentação do Docker. + Acesso ao Docker Hub. Você precisará criar um ID do Docker para acessar o Docker Hub. Para obter mais informações, consulte [Compartilhar a aplicação](https://docs.docker.com/get-started/04_sharing_app/) no site de documentação do Docker. Para saber mais sobre como configurar ambientes do Docker em plataformas do Elastic Beanstalk, consulte [Preparar a imagem do Docker para implantação no Elastic Beanstalk](single-container-docker-configuration.md) neste mesmo capítulo. ### Exemplo simples: fornecer o código do aplicativo Essa é uma maneira fácil de implantar seu GlassFish aplicativo. Forneça o código-fonte da aplicação juntamente com o `Dockerfile` incluído neste tutorial. O Elastic Beanstalk cria uma imagem do Docker que inclui seu aplicativo e a pilha de software. GlassFish Depois, o Elastic Beanstalk executa a imagem nas instâncias do ambiente. Um problema com essa abordagem é que o Elastic Beanstalk cria a imagem do Docker localmente sempre que ela cria uma instância para o ambiente. A criação da imagem aumenta o tempo de provisionamento de instâncias. Esse impacto não se limita à criação inicial do ambiente. Ele também ocorre durante ações de expansão. **Para iniciar um ambiente com um GlassFish aplicativo de exemplo** 1. Faça download do exemplo `docker-glassfish-al2-v1.zip` e expanda o arquivo `.zip` para um diretório em seu ambiente de desenvolvimento. ``` ~$ 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 ``` A estrutura do diretório deve ser a seguinte. ``` ~/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 ``` Os arquivos a seguir são fundamentais para criar e executar um contêiner do Docker em seu ambiente: + `Dockerfile`: fornece instruções que o Docker usa para criar uma imagem com a aplicação e as dependências necessárias. + `glassfish-start.sh`: um script shell que a imagem do Docker executa para iniciar a aplicação. + `Dockerrun.aws.json`— Fornece uma chave de registro, para incluir o log do servidor de GlassFish aplicativos nas [solicitações do arquivo de log](using-features.logging.md). Se você não estiver interessado em GlassFish registros, você pode omitir esse arquivo. 1. Configure o diretório local para implantação no Elastic Beanstalk. ``` ~/glassfish-example$ eb init -p docker {{glassfish-example}} ``` 1. (Opcional) Use o comando **eb local run** para criar e executar seu contêiner localmente. ``` ~/glassfish-example$ eb local run --port 8080 ``` **nota** Para saber mais sobre o comando **eb local**, consulte [**eb local**](eb3-local.md). O comando não é compatível no Windows. Como alternativa, você pode criar e executar seu contêiner com os comandos **docker build** e **docker run**. Para obter mais informações, consulte a [Documentação do Docker](https://docs.docker.com/). 1. (Opcional) Embora o contêiner esteja em execução, use o comando **eb local open** para visualizar o aplicativo em um navegador da web. Opcionalmente, abra [http://localhost:8080/](http://localhost:8080/) em um navegador da Web. ``` ~/glassfish-example$ eb local open ``` 1. Use o comando **eb create** para criar um ambiente e implante seu aplicativo. ``` ~/glassfish-example$ eb create {{glassfish-example-env}} ``` 1. Depois que o ambiente for iniciado, use o comando **eb open** para visualizá-lo em um navegador da web. ``` ~/glassfish-example$ eb open ``` Quando terminar de trabalhar com o exemplo, encerre o ambiente e exclua os recursos relacionados. ``` ~/glassfish-example$ eb terminate --all ``` ### Exemplo avançado: fornecer uma imagem do Docker pré-compilada Essa é uma forma mais avançada de implantar seu GlassFish aplicativo. Com base no primeiro exemplo, você cria uma imagem do Docker contendo o código do aplicativo e a pilha de GlassFish software e a envia para o Docker Hub. Depois de realizar essa etapa única, é possível iniciar ambientes do Elastic Beanstalk com base na imagem personalizada. Ao iniciar um ambiente e fornecer sua imagem do Docker, as instâncias no seu ambiente fazem download e usam essa imagem diretamente e não precisam criar uma imagem do Docker. Portanto, o tempo de provisionamento de instâncias é reduzido. **Observações** As etapas a seguir criam uma imagem do Docker disponível publicamente. Você usará comandos do Docker da instalação local do Docker, juntamente com as credenciais do Docker Hub. Para obter mais informações, consulte a seção *Pré-requisitos* deste tópico. **Para iniciar um ambiente com uma imagem Docker de GlassFish aplicativo pré-criada** 1. Faça download e expanda o exemplo `docker-glassfish-al2-v1.zip` como no [exemplo simples](#docker-glassfish-tutorial.simple) anterior. Se concluiu esse exemplo, é possível usar o diretório que você já tem. 1. Crie uma imagem do Docker e envie-a para o Docker Hub. Insira seu ID do Docker para {{docker-id}} fazer login no Docker Hub. ``` ~/glassfish-example$ docker build -t {{docker-id}}/beanstalk-glassfish-example:latest . ~/glassfish-example$ docker push {{docker-id}}/beanstalk-glassfish-example:latest ``` **nota** Antes de enviar sua imagem, talvez seja necessário executar **docker login**. Suas credenciais do Docker Hub serão solicitadas se você executar o comando sem parâmetros. 1. Crie um diretório adicional. ``` ~$ mkdir glassfish-prebuilt ~$ cd glassfish-prebuilt ``` 1. Copie o exemplo a seguir em um arquivo chamado `Dockerrun.aws.json`. **Example `~/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" } ``` 1. Configure o diretório local para implantação no Elastic Beanstalk. ``` ~/glassfish-prebuilt$ eb init -p docker {{glassfish-prebuilt$}} ``` 1. (Opcional) Use o comando **eb local run** para executar o contêiner localmente. ``` ~/glassfish-prebuilt$ eb local run --port 8080 ``` 1. (Opcional) Embora o contêiner esteja em execução, use o comando **eb local open** para visualizar o aplicativo em um navegador da web. Opcionalmente, abra [http://localhost:8080/](http://localhost:8080/) em um navegador da Web. ``` ~/glassfish-prebuilt$ eb local open ``` 1. Use o comando **eb create** para criar um ambiente e implante sua imagem do Docker. ``` ~/glassfish-prebuilt$ eb create {{glassfish-prebuilt-env}} ``` 1. Depois que o ambiente for iniciado, use o comando **eb open** para visualizá-lo em um navegador da web. ``` ~/glassfish-prebuilt$ eb open ``` Quando terminar de trabalhar com o exemplo, encerre o ambiente e exclua os recursos relacionados. ``` ~/glassfish-prebuilt$ eb terminate --all ```