Site is under maintenance mode. Please wait few min!
Saltar al contenido

Cómo personalizar su Bash Prompt en un VPS Linux

marzo 4, 2020

 

El autor ha seleccionado Code.org para recibir una donación como parte del programa de escritura de donaciones.

Introducción

En un entorno de producción, estibador hace que sea fácil de crear, implementar y ejecutar aplicaciones en el interior de los contenedores. Los contenedores permiten a los desarrolladores de aplicaciones y se reúnen todas sus necesidades básicas y dependencias en un solo paquete que puede convertir una imagen del estibador y se replican en. Docker imágenes se construyen a partir Dockerfiles. El Dockerfile es un archivo donde se define lo que la imagen se verá así, qué sistema operativo base que tendrá y que los comandos se ejecutará dentro de ella.

imágenes grande acoplables pueden alargar el tiempo que se tarda en construir y enviar a las imágenes entre las agrupaciones y los proveedores de nube. Si, por ejemplo, tiene una imagen de gigabytes de tamaño para empujar cada vez que uno de sus desarrolladores provoca una acumulación, el rendimiento se crea en la red se suman durante el proceso de CI / CD, por lo que su aplicación lenta y en última instancia le cuesta recursos . Debido a esto, las imágenes Docker adecuados para la producción sólo deben tener instaladas las necesidades básicas.

Hay varias maneras de disminuir el tamaño de las imágenes acoplables para optimizar la producción. En primer lugar, estas imágenes generalmente no necesitan herramientas de construcción para ejecutar sus aplicaciones, y lo que no hay necesidad de añadir ellos en absoluto. Mediante el uso de un proceso de construcción de varias etapas, puede utilizar imágenes intermedias para compilar y construir el código, instalar las dependencias, y el paquete todo en el tamaño más pequeño posible, y luego copiar la versión final de su aplicación a una imagen vacía sin herramientas de construcción. Además, puede utilizar una imagen con una base pequeña, como Alpine Linux. Alpine es una distribución de Linux adecuado para la producción, ya que sólo tiene lo básico necesario que su aplicación necesita para funcionar.

En este tutorial, optimizar imágenes Docker en unos pocos pasos simples, haciéndolos más pequeños, más rápidos y más adecuado para la producción. Usted va a construir imágenes para una muestra de API Go en varios contenedores de Docker diferentes, comenzando con Ubuntu e imágenes específicos del idioma, a continuación, pasar a la distribución de los Alpes. También se utiliza en varias etapas construye para optimizar sus imágenes para la producción. El objetivo final de este tutorial es para mostrar la diferencia de tamaño entre el uso de imágenes por defecto de Ubuntu y sus homólogos optimizados, y para mostrar la ventaja de múltiples etapas construye. Después de leer a través de este tutorial, será capaz de aplicar estas técnicas a sus propios proyectos y tuberías CI / CD.

Nota: Este tutorial usa una API escrita en Ir como un ejemplo. Esta sencilla API le dará una comprensión clara de cómo se acercaría a la optimización de microservicios van con imágenes acoplables. A pesar de que este tutorial utiliza una API Go, puede aplicar este proceso a casi cualquier lenguaje de programación.

Requisitos previos

Antes de empezar, necesitará:

  • Una Ubuntu 18.04 servidor con una cuenta de usuario no root con privilegios sudo. Sigue nuestra configuración inicial del servidor con Ubuntu 18.04 tutorial para orientación. Aunque este tutorial fue probado en Ubuntu 18.04, puede seguir muchos de los pasos en cualquier distribución de Linux.
  • acoplable instalado en su servidor. Por favor, siga los pasos 1 y 2 de cómo instalar y uso del estibador en Ubuntu 18.04 para obtener instrucciones de instalación.

Una Ubuntu 18.04 servidor con una cuenta de usuario no root con privilegios sudo. Sigue nuestra configuración inicial del servidor con Ubuntu 18.04 tutorial para orientación. Aunque este tutorial fue probado en Ubuntu 18.04, puede seguir muchos de los pasos en cualquier distribución de Linux.

acoplable instalado en su servidor. Por favor, siga los pasos 1 y 2 de cómo instalar y uso del estibador en Ubuntu 18.04 para obtener instrucciones de instalación.

Paso 1 – Descarga de la Muestra Ir API

antes de optimizar su imagen estibador, primero debe descargar la API de la muestra que se va a construir sus imágenes acoplables a partir. Utilizando un sencillo API Go mostrará todos los pasos clave de la construcción y ejecución de una aplicación dentro de un contenedor del estibador. Este tutorial usa Go porque es un lenguaje compilado como C ++ o Java, pero a diferencia de ellos, tiene una huella muy pequeña.

En su servidor, comience por clonación de la muestra Ir API:

git clone https://github.com/do-community/mux-go-api.git

  • git clone https://github.com/do-community/mux-go-api.git

Una vez que ha clonado el proyecto, tendrá un directorio llamado mux-go-API en su servidor. Mover en este directorio con cd:

cd mux-go-api

  • cd mux-go-api

Este será el directorio inicial de su proyecto. Usted va a construir sus imágenes Docker desde este directorio. En el interior, se encuentra el código fuente de una API escrita en Go en el archivo api.go. A pesar de esta API es mínima y tiene sólo unos pocos puntos finales, será apropiado para la simulación de una API listo para la producción a los efectos de este tutorial.

Ahora que ha descargado el API Go muestra, ya está listo para construir una imagen de Ubuntu acoplable base, contra la cual se pueden comparar las imágenes Docker después, optimizados.

Paso 2 – La construcción de una base de Ubuntu imagen

Para su primera imagen del estibador, que será útil para ver cómo se ve cuando se empieza una imagen base de Ubuntu con. Esto empaquetar su API muestra en un entorno similar al software ya está ejecutando en el servidor de Ubuntu. Dentro de la imagen, que va a instalar los diversos paquetes y módulos que necesita para ejecutar su aplicación. Se encuentra, sin embargo, que este proceso crea una imagen bastante pesado Ubuntu que afectará el tiempo de construcción y la legibilidad del código de su Dockerfile.

empezar por escribir un Dockerfile que instruye acoplable para crear una imagen de Ubuntu, instalar Go, y ejecutar la API muestra. Asegúrese de crear la Dockerfile en el directorio de la cesión temporal clonado. Si clonado en el directorio principal debe ser $ HOME / MUX-go-api.

hacer un nuevo archivo llamado Dockerfile.ubuntu. Abrirlo en nano o su editor de texto favorito:

nano ~/mux-go-api/Dockerfile.ubuntu

  • nano ~ / MUX-go-api / Dockerfile.ubuntu

En este Dockerfile, que va a definir una imagen de Ubuntu e instalar Golang. A continuación, procederemos a instalar las dependencias necesarias y construir el binario. Añadir el siguiente contenido a Dockerfile.ubuntu:

FROM ubuntu:18.04

RUN apt-get update -y
&& apt-get install -y git gcc make golang-1.10

ENV GOROOT /usr/lib/go-1.10
ENV PATH $GOROOT/bin:$PATH
ENV GOPATH /root/go
ENV APIPATH /root/go/src/api

WORKDIR $APIPATH
COPY . .

RUN
go get -d -v
&& go install -v
&& go build

EXPOSE 3000
CMD ["./api"]

A partir de la parte superior, el comando de Especifica qué sistema operativo base que tendrá la imagen. A continuación, el comando RUN instala el idioma ir durante la creación de la imagen. ENV establece las variables de entorno específicas del compilador Ir necesita para funcionar adecuadamente. WORKDIR especifica el directorio donde queremos copiar el código y el comando COPY lleva el código del directorio donde Dockerfile.ubuntu es y lo copia encima en la imagen. El último comando RUN instala dependencias Go necesarios para el código fuente para compilar y ejecutar la API.

Nota: Usando los operadores && a los comandos RUN juntas de cuerda es importante en la optimización Dockerfiles, porque cada comando RUN creará una nueva capa, y cada nueva capa aumenta el tamaño de la imagen final.

guarde y salga del archivo. Ahora se puede ejecutar el comando de generación para crear una imagen del estibador del Dockerfile que acaba de hacer:

docker build -f Dockerfile.ubuntu -t ubuntu .

  • ventana acoplable acumulación -f -t Dockerfile.ubuntu ubuntu.

El comando de construcción construye una imagen de un Dockerfile. Los -F especifica que se quiere construir a partir del archivo Dockerfile.ubuntu, mientras -t representa la etiqueta, lo que significa que está etiquetado con el nombre de Ubuntu. El punto final representa el contexto actual donde se encuentra Dockerfile.ubuntu.

Esto llevará un tiempo, así que siéntete libre para tomar un descanso. Una vez finalizada la construcción, tendrá una imagen de Ubuntu listo para ejecutar su API. Pero el tamaño final de la imagen podría no ser ideal; algo por encima de unos pocos cientos de MB para esta API se consideraría una imagen excesivamente grande.

Ejecutar el siguiente comando a la lista de todas las imágenes Docker y encontrar el tamaño de la imagen de Ubuntu: imágenes ventana acoplable

docker images

Vas a ver la salida que muestra la imagen que acaba de crear:

OutputREPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu latest 61b2096f6871 33 seconds ago 636MB
. . .

Como se destaca en la salida , esta imagen tiene un tamaño de 636MB para una API de base Golang, un número que puede variar ligeramente de una máquina a otra. Durante varias composiciones, esta gran tamaño afectará significativamente los tiempos de despliegue y rendimiento de la red.

En esta sección, se construyó una imagen de Ubuntu con todas las herramientas y dependencias para ejecutar la API ha clonado en el paso 1. En la siguiente sección Go necesarios, vamos a usar un pre-construido, el lenguaje específico de la imagen acoplable para simplificar su Dockerfile y agilizar el proceso de construcción.

Paso 3 – La construcción de una imagen base en un idioma específico imágenes

pre-construidos son imágenes base común que los usuarios han modificado para incluir herramientas de situación específicos. Los usuarios pueden empujar estas imágenes a la imagen repositorio acoplable Hub, que permite que otros usuarios utilicen la imagen compartida en lugar de tener que escribir sus propios Dockerfiles individuales. Este es un proceso común en situaciones de producción, y se pueden encontrar varias imágenes pre-construidos sobre Docker Hub para casi cualquier caso de uso. En este paso, se le construye su API muestra usando una imagen Go-específica que ya tiene instalado el compilador y dependencias.

con pre-construido imágenes base que ya contienen las herramientas que necesita para generar y ejecutar la aplicación, se puede reducir el tiempo de construcción de manera significativa. Debido a que usted está comenzando con una base que tiene pre-instalado todas las herramientas necesarias, puede omitir la adición de inmediato a su Dockerfile, dándole un aspecto mucho más limpio y, finalmente, la disminución del tiempo de construcción.

seguir adelante y crear otra Dockerfile y el nombre que Dockerfile.golang. Abrirlo en su editor de texto:

nano ~/mux-go-api/Dockerfile.golang

  • nano ~ / MUX-go-api / Dockerfile.golang

Este archivo será significativamente más concisa que la anterior, ya que tiene todas las dependencias, las herramientas de la Go-específicas, y el compilador preinstalado.

Ahora, agregue las siguientes líneas:

FROM golang:1.10

WORKDIR /go/src/api
COPY . .

RUN
go get -d -v
&& go install -v
&& go build

EXPOSE 3000
CMD ["./api"]

A partir de la parte superior, se encuentra que el FROM ahora es golang: 1,10. Esto significa acoplable buscará una imagen Va pre-construidos a partir del estibador Hub que tiene todas las herramientas necesarias Go ya instalados.

Ahora, una vez más, a construir la imagen acoplable con:

docker build -f Dockerfile.golang -t golang .

  • ventana acoplable acumulación -f -t Dockerfile.golang golang.

Compruebe el tamaño final de la imagen con el siguiente comando: imágenes ventana acoplable

docker images

Esto producirá una salida similar a la siguiente:

OutputREPOSITORY TAG IMAGE ID CREATED SIZE
golang latest eaee5f524da2 40 seconds ago 744MB
. . .

A pesar de que el propio Dockerfile es más eficiente y el tiempo de construcción es más corto , el tamaño total de la imagen en realidad aumentó. La imagen Golang pre-construidos es de alrededor de 744MB , una cantidad significativa.

Esta es la manera preferida para construir imágenes acoplables. Se le da una imagen base, la comunidad ha aprobado como el estándar a utilizar para el idioma especificado, en este caso en Ir. Sin embargo, para hacer una imagen listo para la producción, es necesario cortar las piezas que la aplicación que se ejecuta no necesita.

Tenga en cuenta que el uso de estas imágenes pesadas está bien cuando no está seguro acerca de sus necesidades. No dude en utilizar a ambos como contenedores desechables, así como la base para la construcción de otras imágenes. Para el desarrollo o propósitos, en las que no es necesario pensar en el envío de imágenes a través de la red de prueba, es perfectamente posible utilizar imágenes pesadas. Pero si se quiere optimizar los despliegues, entonces usted necesita para probar su mejor esfuerzo para que sus imágenes tan pequeño como sea posible.

Ahora que ha probado una imagen de un lenguaje específico, se puede pasar a la siguiente etapa, en la que va a utilizar la distribución de peso ligero Alpine Linux imagen como una base para que su imagen del estibador más ligero.

Paso 4 – Imágenes de la construcción de bases Alpine

Uno de los pasos más fáciles de optimizar sus imágenes Docker es el uso de imágenes de base más pequeñas. Alpine es una distribución de Linux ligera diseñada para la seguridad y la eficiencia de los recursos. Los usos imagen Alpine Docker MUSL LIBC y BusyBox para mantenerse compacto, no más de 8 MB que requiere en un recipiente para funcionar. El tamaño pequeño es debido a los paquetes binarios que se diluya y dividida, que le da un mayor control sobre lo que se instala, lo que mantiene el ambiente tan pequeño y eficiente como sea posible.

El proceso de crear una imagen de los Alpes es similar a cómo se creó la imagen de Ubuntu en el paso 2. En primer lugar, crear un nuevo archivo llamado Dockerfile.alpine:

nano ~/mux-go-api/Dockerfile.alpine

  • nano ~ / MUX-go-api / Dockerfile.alpine

Ahora añadir este fragmento:

FROM alpine:3.8

RUN apk add --no-cache
ca-certificates
git
gcc
musl-dev
openssl
go

ENV GOPATH /go
ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
ENV APIPATH $GOPATH/src/api
RUN mkdir -p "$GOPATH/src" "$GOPATH/bin" "$APIPATH" && chmod -R 777 "$GOPATH"

WORKDIR $APIPATH
COPY . .

RUN
go get -d -v
&& go install -v
&& go build

EXPOSE 3000
CMD ["./api"]

Aquí va a añadir el comando apk añadir a utilizar el gestor de paquetes de Alpine para instalar Go y todas las bibliotecas que requiere. Al igual que con la imagen de Ubuntu, es necesario establecer las variables de entorno también.

Ir adelante y construir la imagen:

docker build -f Dockerfile.alpine -t alpine .

  • ventana acoplable acumulación -f -t Dockerfile.alpine alpino.

Una vez más, comprobar el tamaño de la imagen: Imágenes de ventana acoplable

docker images

Usted recibirá una salida similar a la siguiente:

OutputREPOSITORY TAG IMAGE ID CREATED SIZE
alpine latest ee35a601158d 30 seconds ago 426MB
. . .

El tamaño se ha reducido a alrededor de 426MB .

El pequeño tamaño de la imagen de la base de Alpine ha reducido el tamaño de la imagen final, pero hay algunas cosas más que usted puede hacer para que sea aún más pequeño.

A continuación, pruebe a utilizar una imagen de Alpine pre-construidos para Go. Esto hará que el Dockerfile más corto, y también va a reducir el tamaño de la imagen final. Debido a que la imagen de los Alpes pre-construidos para Go está construido con Go compilado desde el código fuente, su huella es significativamente menor.

de inicio mediante la creación de un nuevo archivo llamado Dockerfile.golang-alpino:

nano ~/mux-go-api/Dockerfile.golang-alpine

  • nano ~ / MUX-go-api / Dockerfile.golang-alpino

Añadir los siguientes contenidos en el fichero:

FROM golang:1.10-alpine3.8

RUN apk add --no-cache --update git

WORKDIR /go/src/api
COPY . .

RUN go get -d -v
&& go install -v
&& go build

EXPOSE 3000
CMD ["./api"]

Las únicas diferencias entre Dockerfile.golang-alpina y Dockerfile.alpine son los del mando y el primer comando RUN. Ahora, el FROM especifica una imagen de golang con la etiqueta 1.10-alpine3.8, y RUN sólo tiene un comando para instalar Git. Es necesario Git para el comando de ir a buscar al trabajo en el segundo comando RUN en la parte inferior de Dockerfile.golang-alpina.

construir la imagen con el siguiente comando:

docker build -f Dockerfile.golang-alpine -t golang-alpine .

  • ventana acoplable acumulación -f -t Dockerfile.golang-alpino golang-alpina.

Recuperar la lista de imágenes: imágenes ventana acoplable

docker images

Usted recibirá el siguiente resultado:

OutputREPOSITORY TAG IMAGE ID CREATED SIZE
golang-alpine latest 97103a8b912b 49 seconds ago 288MB

Ahora, el tamaño de la imagen se ha reducido a alrededor de 288 MB .

A pesar de que usted ha logrado reducir el tamaño mucho, hay una última cosa que puede hacer para obtener la imagen lista para la producción. Se llama una acumulación de múltiples etapas. Mediante el uso de múltiples etapas construye, se puede utilizar una imagen para generar la aplicación mientras se utiliza otro, imágenes más claras para empaquetar la aplicación compilada para la producción, un proceso que se ejecutará a través de la siguiente etapa.

Paso 5 – Excluyendo las herramientas de construcción con una estructura multi-etapa

Idealmente, las imágenes que se ejecuta en la producción no debería tener ningún herramientas de construcción instalados o dependencias que son redundantes para la aplicación de producción para ejecutar. Puede eliminar estos de la imagen a la final del estibador construye mediante el uso de múltiples etapas. Esto funciona mediante la construcción de la binaria, o en otros términos, la aplicación Go compilado, en un recipiente intermedio, y luego copiarlo a un recipiente vacío que no tiene ningún dependencias innecesarias.

de inicio mediante la creación de otro archivo llamado Dockerfile.multistage:

nano ~/mux-go-api/Dockerfile.multistage

  • nano ~ / MUX-go-api / Dockerfile.multistage

Lo que vamos a añadir aquí será familiar. Comience por la adición de exactamente el mismo código al igual que con Dockerfile.golang-alpina. Pero esta vez, también añadir una segunda imagen en la que va a copiar el binario de la primera imagen.

FROM golang:1.10-alpine3.8 AS multistage

RUN apk add --no-cache --update git

WORKDIR /go/src/api
COPY . .

RUN go get -d -v
&& go install -v
&& go build

##

FROM alpine:3.8
COPY --from=multistage /go/bin/api /go/bin/
EXPOSE 3000
CMD ["/go/bin/api"]

Guardar y cerrar el archivo. Aquí tienes dos de comandos. La primera es idéntica a Dockerfile.golang-alpino, excepto por tener una de varias etapas adicionales de conformidad con la DE comando. Esto le dará un nombre de varias etapas, que va a continuación, hacer referencia en la parte inferior del archivo Dockerfile.multistage. En el segundo de comandos, se tomará una imagen de alpino base y la copia sobre la aplicación Go compilado a partir de la imagen de varias etapas en ella. Este proceso va a reducir aún más el tamaño de la imagen final, dejándolo listo para la producción.

Ejecutar la acumulación con el siguiente comando:

docker build -f Dockerfile.multistage -t prod .

  • ventana acoplable acumulación -f -t Dockerfile.multistage prod.

Compruebe el tamaño de la imagen ahora, después de usar una acumulación de múltiples etapas. imágenes ventana acoplable

docker images

se encuentran dos nuevas imágenes en lugar de uno solo:

OutputREPOSITORY TAG IMAGE ID CREATED SIZE
prod latest 82fc005abc40 38 seconds ago 11.3MB
d7855c8f8280 38 seconds ago 294MB
. . .

La imagen es la imagen de varias etapas construida con el FROM golang: 1.10-alpine3.8 como comando de varias etapas. Es sólo un intermediario utilizado para construir y compilar la aplicación Go, mientras que la imagen prod en este contexto es la imagen final que sólo contiene la aplicación Go compilado.

De una inicial 744MB , ahora que ha afeitado por el tamaño de la imagen a todo 11.3MB . Hacer un seguimiento de una pequeña imagen como esta y enviarlos a través de la red a los servidores de producción será mucho más fácil que con una imagen de más de 700 MB, y le ahorrará recursos significativos en el largo plazo.

Conclusión

En este tutorial, optimizado para la producción de imágenes Docker utilizando diferentes bases acoplables imágenes y una imagen intermedia para compilar y construir el código. De esta manera, se ha empaquetado su API muestra en el tamaño más pequeño posible. Puede utilizar estas técnicas para mejorar la estructura y la velocidad de despliegue de sus aplicaciones acoplables y cualquier tubería CI / CD que pueda tener.

Si usted está interesado en aprender más sobre la creación de aplicaciones con estibador, visita nuestra Cómo construir una aplicación Node.js con acoplable tutorial. Para obtener más información conceptual en la optimización de los contenedores, consulte construcción optimizada Contenedores para Kubernetes.