Usando Ktor com Docker
Tags: kotlin, docker, braziliandevs
Published: 2021-12-28 04:58:02

## Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade [Kotlinautas](https://twitter.com/kotlinautas/), uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

![capa Kotlinautas](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jreawpvk6whxigcpmctf.png)

## Materiais

Será necessário ter o [Docker](https://www.docker.com/) instalado na máquina e alguma aplicação para praticar. Tanto pode ser alguma aplicação sua, quanto alguma que você encontrar. Caso não tenha idéia de qual aplicação usar para praticar, sugiro usar a [KTasks](https://github.com/Kotlinautas/KTasks), uma aplicação criada pela [Lissa Ferreira](https://twitter.com/lissadev_) e pelo [KastroWalker](https://twitter.com/Kastrowalker/) em um workshop para a Codecon 2021.

## O quê é Docker?

[Docker](https://www.docker.com/) É um software que permite criar imagens de outros softwares, como aplicações Ktor. Facilitando o processo de criação de Containers, agrupando todas as dependências e instruções para rodar um software. Com isso, podemos colocar nossas aplicações Ktor nesses conteiners, facilitando por exemplo o *deploy* dessa aplicações na nuvem por exemplo.

## O quê é o Dockerfile?

*Dockerfile* é o arquivo do Docker onde está as instruções para criar esse container Docker, por isso vamos criar esse arquivo neste artigo.

## Shadow

Precisamos antes, adicionar o Shadow á aplicação que estamos trabalhando. Sobre o Shadow, a Kotlinautas tem um arquivo exclusivo para esse tema, chamado [Usando Shadow em um projeto Kotlin](https://dev.to/kotlinautas/usando-shadow-em-um-projeto-kotlin-17ln).

Toda vez que você criar ou atualizar um container (com a aplicação já pronta), é necessário usar o Shadow para compactar toda a aplicação dentro de um único JAR, com a task do Gradle `shadowjar`.

## Criando o Dockerfile

Para criar esse *Dockerfile* vamos na pasta da nossa aplicação, e vamos criar um arquivo chamado `Dockerfile`.

Nesse arquivo, vamos usar o Alpine com o sistema operacional do container. É um sistema bem leve e muito utilizado para criar containers. Dessa maneira:

```
FROM alpine:3.14
```

Após isso vamos instalar o openjdk no container:

```
FROM alpine:3.14
RUN apk update && apk add openjdk11
```

Agora precisamos criar um diretório chamado `microservices` dentro do container, para iniciar o container dentro desse diretório.

```
FROM alpine:3.14
RUN apk update && apk add openjdk11
RUN mkdir /aplicacao/
WORKDIR /aplicacao/
```

Agora vamos copiar o JAR gerado pelo Shadow nesse novo diretório. O nome desse JAR depende da sua aplicação, logo, mude esse nome no exemplo abaixo:

```
FROM alpine:3.14
RUN apk update && apk add openjdk11
RUN mkdir /aplicacao/
WORKDIR /aplicacao/
COPY build/libs/[ARQUIVO JAR DA APLICAÇÃO] .
```

Após isso, use o comando `CMD` para rodar o arquivo JAR da aplicação:

```
FROM alpine:3.14
RUN apk update && apk add openjdk11
RUN mkdir /aplicacao/
WORKDIR /aplicacao/
COPY build/libs/[ARQUIVO JAR DA APLICAÇÃO] .
CMD ["java", "-jar", "[ARQUIVO JAR DA APLICAÇÃO]"]
```

## Gerando o container

Para gerar o container da aplicação, podemos usar o comando `docker build`, esse comando irá executar nosso *Dockerfile*, gerando a imagem da aplicação.

Logo, na pasta da nossa aplicação (que também está o Dockerfile), execute o comando:

```
docker build -t minha-aplicacao .
```

Com isso, o output desse comando será algo parecido com:

```
Sending build context to Docker daemon  86.17MB
Step 1/6 : FROM alpine:3.14
 ---> 14119a10abf4
Step 2/6 : RUN apk update && apk add openjdk11
 ---> Using cache
 ---> 1de39c8424ab
Step 3/6 : RUN mkdir /aplicacao/
 ---> Using cache
 ---> bfdd62868475
Step 4/6 : WORKDIR /aplicacao/
 ---> Using cache
 ---> e6805f21228f
Step 5/6 : COPY build/libs/com.microservices.user-microservices-0.0.1-all.jar .
 ---> Using cache
 ---> 4ed056dbe9f6
Step 6/6 : CMD ["java", "-jar", "com.microservices.user-microservices-0.0.1-all.jar"]
 ---> Using cache
 ---> 89ec77f86456
Successfully built 89ec77f86456
Successfully tagged minha-aplicacao:latest
```

## Executando a aplicação no Docker

Para executar o container que você criou no Docker, use o comando `docker run`, caso a sua aplicação exteja expondo alguma porta, use a opção `-p` para definir a porta, dessa maneira:

```
docker run minha-aplicacao -p 4500:4500
```

> A porta do exemplo deve ser mudada para a porta que você definiu na sua aplicação.

## Publicando a sua aplicação no DockerHub (Opicional)

Caso você queria, você pode publicar essa sua imagem em uma plataforma chamada [DockerHub](https://hub.docker.com/), com isso a sua imagem ficará pública (ou privada), e poderá ser usada em oquestradores de containers como Kubernetes, Nomad,etc.

Para fazer isso, primeiramente crie uma conta nessa plataforma, e execute o comando `docker login` para logar na plataforma.

Após isso, faça uma build da sua imagem, mas com o nome da imagem da seguinte maneira:

```
[SEU USUÁRIO DOCKERHUB]/[NOME DA IMAGEM]
```

como por exemplo:

```
lissaferreira/user-microservice
```

Após isso, use o comando `docker push` para publicar sua imagem, da seguinte maneira:

```
docker push [SEU USUÁRIO DOCKERHUB]/[NOME DA IMAGEM]
```

como por exemplo:

```
docker push lissaferreira/user-microservice
```

Pronto! Com isso sua imagem estará publicada no DockerHub.

## Finalização

Neste artigo você aprendeu a criar a build da sua aplicação Ktor, para assim, poder fornecer a sua aplicação em forma de containers.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo [@lissatransborda](https://twitter.com/lissatransborda) 👀