0Pricing
Scala for Backend Engineering & Functional Programming · Aula

Conteinerização com Docker

Aprenda a conteinerizar suas aplicações Scala usando Docker para obter ambientes consistentes e simplificar a implantação.

Conteinerização com Docker é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

Por que conteinerizar aplicativos Scala?

Ao implantar aplicativos Scala, garantir um ambiente consistente entre desenvolvimento, testes e produção pode ser um desafio. É aí que entra a conteinerização!

Um contêiner empacota seu aplicativo e todas as suas dependências (como a Máquina Virtual Java, bibliotecas e configurações) em uma única unidade isolada. Isso garante que ele seja executado da mesma forma em qualquer lugar.

Docker: imagens e contêineres

Docker é a plataforma mais popular para conteinerização. Ela utiliza dois conceitos fundamentais:

  • Imagem Docker: um pacote leve, independente e executável que inclui tudo o que é necessário para executar um software, incluindo o código, um ambiente de execução, ferramentas do sistema, bibliotecas do sistema e configurações. Pense nela como um modelo.
  • Contêiner Docker: uma instância executável de uma imagem Docker. Quando você executa uma imagem, ela se torna um contêiner. Os contêineres são isolados uns dos outros e do sistema hospedeiro.

Sua primeira execução do Docker

Vamos tentar executar um contêiner Docker muito básico. Este comando baixa a imagem hello-world (caso ela ainda não esteja disponível) e a executa como um contêiner.

Será exibida uma mensagem confirmando que o Docker está funcionando!

docker run hello-world

Nosso aplicativo Scala simples

Antes de criar o contêiner, vamos criar um aplicativo Scala mínimo. Este programa simplesmente exibirá uma mensagem no console.

Em breve, vamos empacotá-lo em uma imagem Docker!

object Main extends App {
  val message = "Hello from CoddyKit's Docker container!"
  println(message)
}

Modelo: o Dockerfile

Um Dockerfile é um arquivo de texto que contém todos os comandos que um usuário pode chamar na linha de comando para montar uma imagem. É como uma receita para criar sua imagem Docker.

As principais instruções incluem:

  • FROM: define a imagem base.
  • WORKDIR: define o diretório de trabalho.
  • COPY: copia arquivos para a imagem.
  • RUN: executa comandos durante a criação da imagem.
  • CMD: especifica o comando a ser executado quando o contêiner é iniciado.

Dockerfile: etapa de criação para Scala

Para Scala, geralmente usamos uma criação em várias etapas. A primeira etapa cria nosso aplicativo. Usamos uma imagem OpenJDK com um JDK completo para compilar nosso código Scala.

# Stage 1: Build the Scala application
FROM adoptopenjdk/openjdk11:latest as builder
WORKDIR /app
COPY Main.scala .
RUN scalac Main.scala
RUN jar -cvf app.jar Main.class

Dockerfile: etapa de execução para Scala

A segunda etapa cria uma imagem muito menor, contendo apenas o JRE (Ambiente de Execução Java) e nosso aplicativo Scala compilado (o arquivo JAR). Isso mantém o tamanho da imagem final reduzido.

# Stage 2: Create a minimal runtime image
FROM adoptopenjdk/openjdk11:jre-hotspot
WORKDIR /app
COPY --from=builder /app/app.jar .
CMD ["java", "-jar", "app.jar"]

Dockerfile completo para Scala

Veja o Dockerfile completo, com várias etapas, para nosso aplicativo Scala. Este arquivo deve se chamar Dockerfile e ser colocado no mesmo diretório que seu Main.scala.

# Stage 1: Build the Scala application
FROM adoptopenjdk/openjdk11:latest as builder
WORKDIR /app
COPY Main.scala .
RUN scalac Main.scala
RUN jar -cvf app.jar Main.class

# Stage 2: Create a minimal runtime image
FROM adoptopenjdk/openjdk11:jre-hotspot
WORKDIR /app
COPY --from=builder /app/app.jar .
CMD ["java", "-jar", "app.jar"]

Criando a imagem Docker

Agora que temos nosso Dockerfile e Main.scala, vamos criar a imagem Docker. A opção -t atribui um nome à nossa imagem (por exemplo, scala-hello) e . indica que o diretório atual é o contexto da criação.

docker build -t scala-hello .

Executando seu aplicativo Scala em um contêiner

Depois que a imagem for criada, você poderá executar seu aplicativo Scala dentro de um contêiner Docker usando o comando docker run. Isso executará a instrução CMD definida no seu Dockerfile.

docker run scala-hello

Você deverá ver "Hello from CoddyKit's Docker container!" exibido no console!

Verifique seus conhecimentos

Teste sua compreensão sobre Dockerfiles.

Recapitulação: colocando Scala em contêineres

Você aprendeu com sucesso os conceitos básicos de como colocar um aplicativo Scala em um contêiner Docker!

  • As imagens Docker são modelos; os contêineres são instâncias executáveis.
  • Um Dockerfile é uma receita para criar sua imagem.
  • As criações em várias etapas ajudam a criar imagens pequenas e eficientes para aplicativos Scala.
  • Comandos como docker build e docker run gerenciam suas imagens e contêineres.

Esse conhecimento é fundamental para implantar microsserviços Scala de forma consistente e confiável.

Perguntas Frequentes

A aula “Conteinerização com Docker” é grátis?

Sim — o texto completo de “Conteinerização com Docker” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

O que vou aprender em “Conteinerização com Docker”?

Aprenda a conteinerizar suas aplicações Scala usando Docker para obter ambientes consistentes e simplificar a implantação. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Conteinerização com Docker”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Projetando microsserviços Scala
  2. Conteinerização com Docker
  3. Estratégias de implantação na nuvem
← Voltar para Scala for Backend Engineering & Functional Programming