# Docker na EC2: instalar e rodar um container no Amazon Linux

> Lance uma EC2, instale o Docker, construa uma imagem com Apache e abra o site pela porta 80 do Security Group. Aula de dez/2021, no Amazon Linux 2.

- Autor: Henrylle Maia, consultor AWS
- Publicado em: 2026-10-15
- Assuntos: Containers
- URL: https://pages.formacaoaws.com.br/blog/docker-na-ec2/
- Aula de origem: "Como rodar Docker numa AWS EC2" (https://www.youtube.com/watch?v=TU3P1fYcTyc)

Quem começa na AWS lança uma EC2 primeiro, e a pergunta seguinte é como rodar um container nela. Abaixo eu lanço uma instância, instalo o Docker, construo uma imagem com o Apache a partir de um Dockerfile e abro uma página HTML pelo navegador, expondo a porta 80 no Security Group.

> **Importante:** esta é uma aula de 29 de dezembro de 2021, com Amazon Linux 2 e o console daquela época. Os nomes das telas e o comando de instalação do Docker mudam com o tempo. Para instalar hoje, siga o guia oficial da AWS, que parte do Amazon Linux 2023: [Create a container image (Amazon ECS)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-container-image.html). Outra versão da tela de lançamento, de 2022, está em [Lançar EC2 no novo console da AWS](https://pages.formacaoaws.com.br/blog/novo-console-ec2-lancar-instancia/).

## Antes de lançar: Security Group e par de chaves

Dois pré-requisitos têm de existir antes de lançar a instância: um Security Group e um par de chaves. Os dois entram na tela de lançamento como escolha, não como criação.

O Security Group do exemplo tem só duas regras de entrada: SSH liberado para o meu IP e a porta 80 liberada para todo mundo. A porta 80 é onde a aplicação web vai rodar. O par de chaves eu guardo numa pasta própria para as chaves, o que facilita a conexão depois.

> **Importante:** a porta 80 aberta para todos faz sentido aqui porque a página é pública. O SSH ficou restrito ao meu IP, e é assim que deve ficar. Para entender as regras de entrada, veja o [guia de Security Groups da AWS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html).

## Passo 1: lançar a instância

Na região de Ohio, em **Launch Instance**, escolhi estas opções:

- **AMI:** Amazon Linux 2, com o kernel 5.10, na arquitetura x86 (a padrão);
- **Tipo:** t3a.micro, pequena e suficiente para o teste. Para o Free Tier, use a t2.micro ou a t3.micro (a t3.micro é a que eu uso); confirme na documentação da AWS o que o Free Tier cobre hoje;
- **Rede:** VPC padrão, sem preferência de subnet, e Auto-assign Public IP habilitado;
- **Armazenamento:** 8 GB em gp2, mais que o necessário para um exemplo;
- **Nome:** `Aula exemplo docker EC2`;
- **Security Group:** o que eu já tinha criado, e na hora do lançamento o par de chaves.

Revisei tudo em **Review and launch** e lancei. Se você escolher uma chave que não tem o arquivo da chave privada, não consegue acessar a instância.

## Passo 2: conectar por SSH

Na instância, **Connect** e a aba **SSH client** trazem o comando pronto. Entre na pasta onde está o arquivo `.pem`, cole o comando e conecte.

Em poucos segundos a instância Linux já estava disponível. É um dos motivos pelos quais eu recomendo trabalhar com Linux e evitar Windows quando dá: numa instância Windows a espera seria de quatro a cinco minutos.

## Passo 3: instalar o Docker na EC2

Segui o passo a passo de um Gist que explica a instalação no Amazon Linux 2, usando o pacote da própria Amazon:

```bash
sudo amazon-linux-extras install docker
```

O comando pede confirmação, e a instalação termina rápido. Em seguida, três comandos:

```bash
sudo service docker start
sudo usermod -a -G docker ec2-user
sudo chkconfig docker on
```

O primeiro inicia o serviço. O segundo dá ao usuário `ec2-user` permissão para usar o Docker, para eu não precisar do usuário root a cada comando. O terceiro habilita o início automático do Docker sempre que a instância reinicia. Por fim, um `sudo reboot`.

![Terminal da EC2 com os três comandos depois da instalação: service docker start, usermod para o grupo docker e chkconfig docker on](https://pages.formacaoaws.com.br/blog/assets/posts/docker-na-ec2/instalar-e-habilitar.webp)

Reconectei pelo mesmo comando SSH e conferi a versão do Docker. Para provar que ele roda dentro da instância, rodei o container de teste:

```bash
docker run hello-world
```

A mensagem "Hello from Docker" confirma que o Docker está funcionando na EC2.

**Fluxo:** Security Group (SSH no meu IP, porta 80 aberta) → EC2 (t3a.micro, Amazon Linux 2) → Docker (instalado e ativo no boot) → Imagem (Dockerfile com httpd) → Container (porta 80 da EC2 para o 80 do container)

## Passo 4: criar a página e o Dockerfile

Na pasta do usuário, criei a pasta `site` e, dentro dela, a pasta `html`. Dentro de `html`, um arquivo `home.html` com uma frase: "agora meu site funciona numa EC2 com docker".

Na pasta `site`, criei o `Dockerfile`. Ele é a documentação da imagem: parte de uma imagem pronta do Apache, a fonte oficial no Docker Hub, e copia o conteúdo da pasta `html` para a pasta que o Apache publica.

```dockerfile
FROM httpd:2.4
COPY ./html/ /usr/local/apache2/htdocs/
```

Eu não explico aqui o que é imagem, container e Dockerfile; isso está em [O que é Docker: imagem, container e Dockerfile na prática](https://pages.formacaoaws.com.br/blog/o-que-e-docker/). Aqui só executo.

## Passo 5: construir a imagem

Na pasta `site`:

```bash
docker build -t meu-site .
```

O `-t` dá o nome (a tag) à imagem, e o ponto é o diretório atual, usado como base. O Docker baixa o `httpd` e executa os passos do Dockerfile. Ao terminar, `docker images` lista a imagem `meu-site`, criada há 11 segundos.

![Saída do docker build com os dois passos do Dockerfile (FROM httpd:2.4 e COPY) e a lista do docker images, com a imagem meu-site criada há 11 segundos, 144MB](https://pages.formacaoaws.com.br/blog/assets/posts/docker-na-ec2/build-e-images.webp)

## Passo 6: rodar o container e abrir o site

Com a imagem pronta, rodo o container em modo daemon, sem acompanhar a saída. O nome é `meu-site-rodando`, a porta 80 da instância vai para a porta 80 do container e a imagem é a `meu-site`:

```bash
docker run -d --name meu-site-rodando -p 80:80 meu-site
```

O hash que aparece indica que o container subiu. O `docker ps` mostra um container rodando na porta 80. Para abrir a página, copio o endereço público da instância no console, acrescento `/home.html` e abro no navegador por HTTP. A frase do `home.html` aparece: o meu site funciona na EC2 com Docker.

## Passo 7: por que mudar o HTML não muda o site

Ao copiar a pasta `html` no Dockerfile, o conteúdo fica congelado dentro da imagem. Para mostrar, editei o `home.html` e acrescentei três exclamações. Com o container rodando, a página não mudou, porque a alteração não está na imagem.

Para atualizar, é preciso construir uma nova imagem. Nesta aula não mostro como trocar o container sem derrubar a aplicação: do jeito que fiz, a mudança causaria indisponibilidade. O fluxo da aula é de laboratório, para você ver container rodando na AWS, e ele não escala. Para escalar existe o ECS, e dois posts seguem desse ponto: [Docker com alta disponibilidade na AWS](https://pages.formacaoaws.com.br/blog/docker-alta-disponibilidade-na-aws/) e [Primeiro container Docker em produção no Amazon ECS](https://pages.formacaoaws.com.br/blog/primeiro-container-em-producao-no-ecs/).

## Passo 8: terminar a instância

Para não ficar com custo depois do laboratório, desaloque o que lançou. No console, em **Terminate instance**: o volume EBS criado com a instância também é desalocado, e você não paga por ele depois. A documentação da AWS sobre o assunto está em [Terminar uma instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html).

## Sem instalar à mão: user data e Session Manager

Na aula de [1º de junho de 2023](https://www.youtube.com/watch?v=rYWjsOWGmxU), com Amazon Linux 2023, eu lanço a EC2 já com o Docker pronto, sem entrar nela para instalar nada. O segredo está em **Advanced Details**, no campo **User Data**: um script que roda no boot quando a instância nasce. Se você parar e iniciar a instância de novo, ele não roda outra vez, só no primeiro lançamento.

O script que usei atualiza o sistema, instala Git e Docker, coloca o `ssm-user` no grupo `docker` e habilita e inicia o serviço:

```bash
#!/bin/bash

sudo yum update -y
sudo yum install git -y
sudo yum install docker -y
sudo usermod -a -G docker ssm-user
sudo newgrp docker

#Ativar docker
sudo systemctl enable docker.service
sudo systemctl start docker.service
```

Uma versão mais completa, com o User Data lado a lado no console, na CLI e no Terraform, está em [EC2 com Terraform, CLI e console](https://pages.formacaoaws.com.br/blog/ec2-com-terraform-cli-e-console/).

Lancei sem par de chaves e conectei por **Session Manager**, com uma role de acesso SSM na instância, então não precisei de chave `.pem` nem de SSH liberado. Lá dentro, `docker --version` e `git --version` já responderam. No teste, `docker run -d -p 80:80 nginx` deu permissão negada para o `ssm-user`, que não tinha entrado no grupo, então rodei como root (`sudo su`) e o Nginx subiu na porta 80, com o Security Group liberando a porta 80.

## Checklist

- Crie o Security Group com SSH só para o seu IP e a porta 80 aberta, e o par de chaves, antes de lançar.
- Lance a instância com IP público automático e escolha o Security Group e a chave.
- Conecte por SSH pelo comando da aba SSH client.
- Instale o Docker, inicie o serviço, dê o grupo `docker` ao `ec2-user` e habilite o início automático.
- Reinicie, reconecte e rode `docker run hello-world`.
- Crie `html/home.html` e um `Dockerfile` com `FROM httpd:2.4` e `COPY`.
- Construa com `docker build -t meu-site .` e rode com `docker run -d --name meu-site-rodando -p 80:80 meu-site`.
- Lembre que alterar o HTML exige construir uma nova imagem.
- Termine a instância ao fim do laboratório.

Rodar Docker numa EC2 é um bom laboratório para ver o container no ar. Se você quer aprender esse caminho na prática, até o ECS, a Formação AWS faz isso passo a passo.