Comprender las compilaciones de múltiples masadas de etapas

La construcción de múltiples etapas en Docker especifica una serie de compilaciones en un Dockerfile. Las instrucciones de Dockerfile se dividen en múltiples secciones o niveles y contienen más de una "DE" declaración. En la construcción de varias etapas, el proceso de desarrollo se divide en múltiples etapas. El primer comando "desde" define la imagen principal o base, y esta sección contiene principalmente las instrucciones de instalación o configuración, y las subsecciones utilizan las dependencias de la instrucción base.

Esta publicación demostrará el concepto básico de la construcción de Docker de varias etapas.

Diferencia entre la construcción simple y la construcción de múltiples etapas

La construcción simple contiene solo una "DE"Para especificar la imagen base. Todas las dependencias de instalación y los archivos de origen se procesan en una sola sección. La imagen construida a través de la construcción simple también es enorme en tamaño. Sin embargo, las construcciones de varias etapas se dividen en múltiples etapas y tienen múltiples declaraciones "de". La construcción de varias etapas también es útil para reducir el tamaño de la imagen. También se puede utilizar si los usuarios desean procesar o crear imágenes en fragmentos para ejecutar código en secciones.

Cómo hacer una imagen a partir de compilaciones de varias etapas?

Para hacer una imagen de Docker simple a partir de compilaciones de varias etapas, primero, cree un Dockerfile de nivel múltiple. Luego, ejecute el "construir"Comando de Docker para construir la imagen. Para hacerlo, mira los pasos dados.

Paso 1: terminal abierto

Primero, inicie el terminal desde el menú de inicio para usar Docker CLI. Para hacerlo, utilizaremos el "Git Bash"En Windows:

Abra el directorio/carpeta de la aplicación con la ayuda del "cd" dominio:

$ CD MULT MULTITAJE

Paso 2: Crear archivo de código

A continuación, cree un archivo de programa. Para este propósito, hemos utilizado el editor de texto Nano para crear un "principal.ir" Archivo de programa. Sin embargo, también puede usar el editor de códigos de Bloc de notas o Visual Studio:

$ nano principal.ir

Pegue el código dado a continuación en el archivo:

importar (
"FMT"
"registro"
"net/http"
)
Funchandler (w http.Responsewriter, r *http.Pedido)
fmt.Fprintf (w, "Hola! Bienvenido al tutorial de Linuxhint ")

funcmain ()
http.Manefunc ("/", manejador)
registro.Fatal (http.Listenandserve ("0.0.0.0: 8080 ", nil))

Paso 3: Crear Dockerfile de varias etapas

A continuación, genere y abra "Dockfile"En un editor de texto Nano para especificar las instrucciones de varias etapas para la compilación de varias etapas:

$ nano dockerfile

Copie el fragmento a continuación en Dockerfile. Aquí, las instrucciones de Dockerfile se dividen en dos secciones:

• La primera sección usa el "Golang: 1.8"Como imagen base y contiene las instrucciones básicas.
• La segunda sección utiliza el "alpino"Imagen y define los valores predeterminados o el punto de entrada a través de la declaración" CMD ":

De Golang: 1.8 como base
WorkDir/Go/SRC/App
Copia principal.ir .
Ejecutar ir compilación -o servidor web .
De alpino
WorkDir /App
Copiar ---From = Base/Go/Src/App/App/
CMD ["./Servidor web"]

Paso 4: Generar una imagen de Docker de varias etapas

Usando un DockerFile de varias etapas, genere la imagen a través del "Docker Build" dominio. Aquí, para definir la etiqueta/nombre de una imagen, hemos utilizado el "-T" bandera:

$ Docker Build -T New-Web-Image .

Verifique si la imagen se crea o no utilizando el "Imágenes de Docker " dominio:

$ Docker Images New-Web-Image

La siguiente salida muestra que se crea la imagen y el tamaño de la imagen es solo "12.9MB":

Paso 4: Ejecutar Docker Image

Para ejecutar la imagen para crear e iniciar un contenedor para la implementación del programa, revise el comando mencionado. Aquí el "-pagSe utiliza la bandera para asignar el puerto expuesto del contenedor:

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

Visite el puerto de exposición del host local en el navegador para verificar si el contenedor está iniciado o no:

De la imagen de arriba, puede ser claro que hemos implementado el programa a través de la compilación de varias etapas.

Conclusión

En la construcción de varias etapas, el proceso de desarrollo se divide en múltiples etapas. El DockerFile se divide en múltiples secciones y tiene múltiples "DE" declaraciones. Se puede utilizar si los usuarios desean procesar o crear imágenes en fragmentos para ejecutar código en las secciones. La construcción de varias etapas también es útil para reducir el tamaño de la imagen. Este artículo ha demostrado la comprensión básica de las compilaciones de múltiples etapas de Docker.