Um guia para iniciantes para uma compilação do Docker de vários estágios

Docker Multi-Stage Build é o processo de especificar uma série de compilações em um Dockerfile. Em outras palavras, o Dockerfile contém múltiplos “DE”Declarações em um único arquivo, e o novo da declaração utiliza instruções base diferentes ou anteriores. A construção de vários estágios permite que os desenvolvedores dividam o processo de desenvolvimento em vários estágios. Além disso, a instrução base é chamada de Instruções de Instalação ou Configuração, e outras instruções usam dependências de instrução básica para funcionar corretamente.

Esta redação fornecerá um guia para uma compilação do Docker de vários estágios.

Um guia para iniciantes para uma compilação do Docker de vários estágios

Para criar uma imagem do Docker através do simples Dockerfile e do DockerFile Builds, dê uma olhada nos métodos listados:

• Como construir uma imagem simples do Docker?
• Como construir uma imagem do Docker a partir de multistage Dockerfile?

Como construir uma imagem simples do Docker?

Para criar uma imagem simples do docker usando um Dockerfile simples, passe pelas instruções fornecidas.

Etapa 1: Terminal aberto
Das janelas “ComeceMenu, abra o terminal Git:

Etapa 2: Crie um novo diretório
Em seguida, crie um novo diretório de projeto usando o comando fornecido:

$ mkdir multistage

Depois disso, abra o diretório do projeto com a ajuda do “cd”Comando:

$ CD MultiStage

Etapa 3: Criar arquivo de programa
Crie e abra um novo arquivo de programa para implementar o “Golang" programa. Por exemplo, criamos um “principal.ir" arquivo:

$ nano Main.ir

Cole o código fornecido no “principal.ir" arquivo. Este programa imprimirá a saída simples “Olá! Bem -vindo ao Tutorial Linuxhint”No host local:

importação (
"FMT"
"registro"
"net/http"
)
manipulador func (w http.ResponseWriter, r *http.Solicitar)
fmt.Fprintf (w, "Olá! Bem -vindo ao Tutorial Linuxhint ")

func main ()
http.Handlefunc ("/", manipulador)
registro.Fatal (http.ListenAndServe ("0.0.0.0: 8080 ", nil))

Imprensa "Ctrl+o”Para salvar as mudanças e“Ctrl+x" sair.

Etapa 4: Crie Dockerfile
Crie e abra um novo Dockerfile no editor de texto Nano usando o “Nano Dockerfile”Comando:

$ Nano Dockerfile

Cole o seguinte código dentro do “Dockerfile”Isso instruirá o contêiner sobre como implantar o projeto:

De Golang: 1.8
Workdir/go/src/app
Cópia principal.ir .
Run Go Build -O WebServer .
Cmd ["./servidor web"]

Imprensa "Ctrl+o”Para salvar o arquivo e“Ctrl+x”Para sair do editor:

Etapa 5: Crie imagem do Docker
Com a ajuda do Dockerfile, crie uma nova imagem do Docker através do “Docker Build”Comando. O "-t”A tag é usada para especificar a tag/nome da imagem:

$ Docker Build -t New-Web-Image .

Etapa 6: Execute a imagem do Docker
Depois de criar a imagem do Docker, utilize o comando abaixo mencionado para executar a imagem do Docker. O "-p”A opção é usada para especificar o número da porta em que o contêiner do Docker executará o programa:

$ Docker Run -P 8080: 8080 New-Web-Image

Depois disso, navegue para “http: // localhost: 8080”Para verificar se o aplicativo está em execução ou não:

Na saída acima, você pode ver que implantamos com sucesso o aplicativo no localhost:

Etapa 7: Verifique as imagens do Docker
Por fim, execute o “Imagens do Docker ”Comando para verificar as informações adicionais sobre a imagem do docker recém -criada:

$ Docker Images New-Web-Image

Pode -se observar que o tamanho da imagem do docker é muito grande para executar o pequeno projeto. Nesse cenário, a construção de vários estágios pode ser utilizada para reduzir o tamanho da imagem do Docker:

Como construir uma imagem do Docker a partir de multistage Dockerfile?

Para criar um DockerFile de vários estágios para dividir os processos de desenvolvimento em palcos e reduzir o tamanho da imagem, dê uma olhada nas etapas fornecidas.

Etapa 1: aberto Dockerfile
Primeiro, abra o Dockerfile no “Editor de texto Nano”Através do comando mencionado:

$ Nano Dockerfile

Etapa 2: Crie Dockerfile de vários estágios
Cole o seguinte código no Dockerfile. Pode -se notar que o arquivo do docker contém mais de um “DE”Declaração, o que significa que estamos criando um Dockerfile de vários estágios:

De Golang: 1.8 como base
Workdir/go/src/app
Cópia principal.ir .
Run Go Build -O WebServer .
De alpino
WorkDir /App
Cópia - -from = base/go/src/app/app/
Cmd ["./servidor web"]

Imprensa "Ctrl+o”Para salvar mudanças e“Ctrl+x”Para sair do editor.

Etapa 3: Crie a imagem do Docker
Agora, construa a nova imagem do Docker com a ajuda de uma compilação em vários estágios. Para esse fim, execute o comando dado:

$ Docker Build -t New-Web-Image .

Novamente, verifique as informações adicionais sobre a imagem do Docker através do “Imagens do Docker”Comando:

$ Docker Images New-Web-Image

A saída mostra que criamos com sucesso um arquivo do docker e o tamanho do arquivo do docker é reduzido a apenas “12.9 MB”:

Etapa 4: Execute a imagem do Docker
Por fim, execute a imagem do Docker para executar o contêiner para verificar se a imagem do Docker está funcionando corretamente ou não:

$ Docker Run -P 8080: 8080 New-Web-Image

Abra o servidor host local navegando para o “http: // localhost: 8080”No navegador:

A saída mostra que implantamos com sucesso o programa por meio de uma compilação de vários estágios.

Conclusão

A compilação do Docker Multistage especifica a série de construções em palcos. Para criar um Dockerfile de vários estágios, especifique mais de uma declaração "de" e consulte o primeiro "DE”Declaração como a construção da base. Depois disso, crie uma nova imagem do Docker usando o “Docker Build -t .”Comando. O post elaborou um guia completo para uma compilação do Docker de vários estágios.