# SQL Server com Docker na EC2: container, túnel SSH e restore

> Rode o SQL Server em um container Docker numa EC2, conecte pelo DBeaver com túnel SSH e restaure o banco AdventureWorks passo a passo.

- Autor: Henrylle Maia, consultor AWS
- Publicado em: 2026-10-15
- Assuntos: Containers, Banco de dados
- URL: https://pages.formacaoaws.com.br/blog/sql-server-com-docker-na-ec2/
- Aula de origem: "Como lançar SQL Server com Docker na AWS + restore de banco e conexão com túnel SSH" (https://www.youtube.com/watch?v=5BaqMTBGQSc)

Você conhece o SQL Server e quer rodá-lo em um container, na AWS, sem instalar nada na sua máquina. Aqui eu lanço uma EC2, subo o SQL Server com Docker, conecto pelo DBeaver por um túnel SSH e restauro o banco de exemplo AdventureWorks, da Microsoft.

Esta aula é de julho de 2023. Imagem, tag da versão e páginas da Microsoft mudam com o tempo: confira a [página oficial da imagem no Docker Hub](https://hub.docker.com/_/microsoft-mssql-server) e o [guia da Microsoft para rodar o SQL Server em container](https://learn.microsoft.com/en-us/sql/linux/quickstart-install-connect-docker) antes de copiar os comandos.

## O que vamos montar

Uma EC2 com Docker. Dentro dela, um container com o SQL Server escutando na porta 1433, a porta padrão dele. Na minha máquina, o DBeaver fala com a porta local 1436, e um túnel SSH leva essa conexão até a 1433 da EC2.

Eu uso o DBeaver porque estou numa máquina Linux e não consigo instalar o SQL Server Management Studio. Qualquer cliente de SQL Server serve.

Não vou explicar o básico de Docker nem de lançar instância. Se for novo nisso, comece por [Docker na EC2](https://pages.formacaoaws.com.br/blog/docker-na-ec2/) e [O que é Docker](https://pages.formacaoaws.com.br/blog/o-que-e-docker/).

## Passo 1: lançar a EC2 já preparada para o Docker

O SQL Server em container pede **pelo menos 4 GB de memória**. Por isso uso uma **t3.medium**, que tem 4 GB, e não uma t3.micro. Na aula, em 2023, o laboratório saiu por menos de 50 centavos com o ambiente ligado por duas horas. Confira o preço atual da t3.medium na sua região.

1. Crie um security group só com **SSH, liberado para o seu IP**.
2. Lance a instância: Amazon Linux, t3.medium, a VPC padrão, o security group que você criou e um par de chaves `.pem`. Disco de 8 GB é suficiente.
3. Em **Advanced details**, cole um script de **user data** que instala o Docker. Usei o mesmo script do meu bootcamp, o `user data EC2 zona A`, da pasta `scripts` do projeto no GitHub.
4. No final desse script há um processo de swap. Tirei, porque aqui não precisa.

O user data deixa a máquina pronta com o Docker, sem eu rodar comando por comando depois. Quando a instância subir, conecte por SSH com o comando que o console mostra em **Connect to instance**.

## Passo 2: subir o SQL Server no container

A imagem está no Docker Hub, repositório oficial do Docker. Pesquise "SQL Server Docker" no Google: o primeiro resultado é a página das imagens do SQL Server baseadas em Ubuntu, com a versão 2022 e o comando de exemplo. Copie dali e troque a senha:

```bash
docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=<sua-senha-forte>" \
  -p 1433:1433 -d mcr.microsoft.com/mssql/server:2022-latest
```

- `ACCEPT_EULA=Y` aceita os termos de uso.
- `MSSQL_SA_PASSWORD` é a senha do usuário SA. Use maiúscula, minúscula e caractere especial.
- `-p 1433:1433` publica a porta do container na porta 1433 da EC2.

O Docker baixa a imagem do Docker Hub e sobe o container. Confira com `docker ps`: o container aparece rodando, com a 1433 mapeada.

> **Importante:** na aula, a senha foi escrita direto no comando e era uma senha de teste. No seu ambiente, use uma senha forte e não a deixe em texto no comando nem em script versionado. Para guardar senha de forma segura na AWS, veja [Senha em variável de ambiente: Secrets Manager](https://pages.formacaoaws.com.br/blog/senha-em-variavel-de-ambiente-secrets-manager/) e a [documentação do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html).

## Passo 3: abrir o túnel SSH e conectar no DBeaver

O security group só libera SSH, então o DBeaver não chega na 1433 direto. O túnel resolve: abra um novo terminal, na pasta onde está a chave `.pem`.

```bash
ssh -f -N -i <chave>.pem -L 1436:<ip-privado-da-ec2>:1433 ec2-user@<ip-publico-da-ec2>
```

- `-f` roda em segundo plano.
- `-N` não executa comando remoto: só abre o túnel.
- `-L` redireciona a porta local 1436 para a 1433 da EC2. Usei a 1436 porque a 1435 eu já usava na minha máquina.
- O destino é o IP privado da EC2, e a máquina de salto é a própria EC2, pelo IP público.

Na primeira tentativa recebi "permissão negada": faltava o `ec2-user@` antes do IP. Com o usuário certo, o comando volta sem nenhuma saída, e saída vazia é sinal de que o túnel abriu.

**Fluxo:** DBeaver (localhost:1436) → Túnel SSH (porta 22 da EC2) → EC2 (Docker instalado pelo user data) → Container (SQL Server na 1433)

No DBeaver, crie uma nova conexão do tipo **SQL Server**:

1. Host `localhost`, porta `1436`, banco `master`.
2. Usuário `sa` e a senha que você definiu no `docker run`.
3. Clique em **Test Connection**. Se der certo, o DBeaver mostra a versão do servidor: SQL Server 2022.

![O teste de conexão do DBeaver em localhost:1436, com o usuário sa, respondendo Connected e SQL Server 2022](https://pages.formacaoaws.com.br/blog/assets/posts/sql-server-com-docker-na-ec2/dbeaver-conexao-sa-localhost-1436.webp)

Para ver o túnel SSH em outro cenário, leia [Acesso seguro ao RDS: bastion host e túnel SSH](https://pages.formacaoaws.com.br/blog/acesso-seguro-ao-rds-bastion-host/).

## Passo 4: baixar o AdventureWorks e copiar para dentro do container

Conectado, o banco AdventureWorks ainda não existe. Para restaurar um backup, o arquivo precisa estar no servidor, e o servidor aqui é o container. O arquivo precisa chegar até a EC2 e, dali, entrar no container.

Os bancos de exemplo estão no repositório da própria Microsoft: [AdventureWorks, na página de releases do sql-server-samples](https://github.com/microsoft/sql-server-samples/releases/tag/adventureworks). Usei o AdventureWorks 2022, mas pode ser o 2019. Na EC2, baixe direto com `wget`, colando o endereço do arquivo `.bak`:

```bash
wget <endereço-do-AdventureWorks2022.bak>
ls
```

O `ls` mostra o `AdventureWorks2022.bak` na EC2. Agora copie para dentro do container, na pasta padrão de dados e backup do SQL Server:

```bash
docker cp AdventureWorks2022.bak <id-do-container>:/var/opt/mssql/data
```

O `<id-do-container>` aparece no `docker ps`. Para confirmar que o arquivo chegou, entre no container e liste a pasta:

```bash
docker exec -ti <id-do-container> bash
ls /var/opt/mssql/data/
```

![Dentro do container, o ls de /var/opt/mssql/data lista o AdventureWorks2022.bak ao lado do master.mdf e dos outros arquivos do SQL Server](https://pages.formacaoaws.com.br/blog/assets/posts/sql-server-com-docker-na-ec2/exec-ls-bak-no-container.webp)

## Passo 5: restaurar o banco

Faço o restore em dois passos, pelo editor SQL do próprio DBeaver.

**Primeiro, descubra os nomes lógicos dos arquivos do backup:**

```sql
RESTORE FILELISTONLY FROM DISK = 'AdventureWorks2022.bak';
```

A saída lista os dois arquivos do banco, o de dados e o de log. Vou usar esses nomes no próximo comando.

**Depois, restaure o banco com um nome novo:**

```sql
RESTORE DATABASE AdventureWorks
FROM DISK = 'AdventureWorks2022.bak'
WITH
  MOVE 'AdventureWorks2022'     TO '/var/opt/mssql/data/AdventureWorks2022.mdf',
  MOVE 'AdventureWorks2022_log' TO '/var/opt/mssql/data/AdventureWorks2022_log.ldf';
```

- O `.mdf` é o arquivo de dados e o `.ldf`, o de log.
- Quem usa SQL Server já conhece esses arquivos. A diferença é o caminho: o que o FILELISTONLY mostra parece caminho de Windows, mas dentro do container é Linux, e vale o `/var/opt/mssql/data`, onde você copiou o backup.
- O `FROM DISK` leva só o nome do arquivo, como no `FILELISTONLY`.

O comando termina com a mensagem de que o restore foi processado com sucesso.

![O RESTORE DATABASE com os dois MOVE, no painel de estatísticas do DBeaver depois de rodar](https://pages.formacaoaws.com.br/blog/assets/posts/sql-server-com-docker-na-ec2/restore-database-com-move.webp)

Atualize a conexão no DBeaver e o banco **AdventureWorks** aparece, com as tabelas dos esquemas `dbo`, `HumanResources`, `Person`, `Production`, `Purchasing` e `Sales`.

![O banco AdventureWorks restaurado na conexão localhost:1436 do DBeaver, com os esquemas dbo, HumanResources, Person, Production, Purchasing e Sales](https://pages.formacaoaws.com.br/blog/assets/posts/sql-server-com-docker-na-ec2/adventureworks-restaurado.webp)

## Isso serve para desenvolvimento, não para produção

SQL Server em Docker é ótimo para você não precisar instalá-lo na sua máquina: sobe rápido e some rápido num ambiente de teste. Na minha opinião, para produção não serve. Em produção entram aplicar atualizações, restaurar um backup, fazer backup de tempos em tempos e ter mais disponibilidade, como um Multi-AZ. Fazer tudo isso à mão, com Docker, é muita complexidade para você gerenciar.

Para essa realidade a AWS tem o serviço certo, o RDS. Veja a [documentação do Amazon RDS para SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html). Se nunca criou um banco no RDS, o caminho está em [Criar um banco no RDS e conectar pelo DBeaver](https://pages.formacaoaws.com.br/blog/criar-banco-rds-e-conectar/).

## Desligue a EC2 no fim

Ao terminar, desligue a EC2 que lançou. Ela tem custo por hora enquanto estiver ligada.

## Checklist

- Lancei a EC2 com pelo menos 4 GB de memória (t3.medium).
- O security group libera só o SSH, para o meu IP.
- O user data instalou o Docker e o `docker ps` funciona.
- Subi o container com `ACCEPT_EULA=Y`, uma senha forte no SA e a porta 1433.
- Abri o túnel SSH da porta local 1436 para a 1433 da EC2.
- Conectei no DBeaver em `localhost:1436` com o usuário `sa`.
- Copiei o `.bak` com `docker cp` para `/var/opt/mssql/data` e conferi com `ls`.
- Rodei o `RESTORE FILELISTONLY` e depois o `RESTORE DATABASE` com os dois `MOVE`.
- Desliguei a EC2 no fim do laboratório.