O primeiro paso para implementar en Kubernetes é colocar a túa aplicación nun contedor. Nesta serie, veremos como podes crear unha imaxe de contedor pequena e segura.
Grazas a Docker, crear imaxes de contedores nunca foi tan fácil. Especifique unha imaxe base, engada os seus cambios e cree un contedor.
Aínda que esta técnica é excelente para comezar, o uso de imaxes base predeterminadas pode levar a un traballo inseguro con imaxes grandes cheas de vulnerabilidades.
Ademais, a maioría das imaxes en Docker usan Debian ou Ubuntu para a imaxe base, e aínda que isto proporciona unha excelente compatibilidade e unha personalización sinxela (un ficheiro de Docker só leva dúas liñas de código), as imaxes base poden engadir centos de megabytes de carga adicional ao teu contedor. Por exemplo, un ficheiro node.js simple para unha aplicación Go "hello-world" ten uns 700 megabytes, mentres que a túa aplicación real ten uns poucos megabytes de tamaño.
Polo tanto, toda esta carga de traballo extra é un desperdicio de espazo dixital e un gran agocho para as vulnerabilidades de seguridade e os erros. Entón, vexamos dúas formas de reducir o tamaño dunha imaxe de contedor.
O primeiro é o uso de imaxes de base pequenas, o segundo é o uso do Patrón do constructor. Usar imaxes de base máis pequenas é probablemente a forma máis sinxela de reducir o tamaño do teu recipiente. O máis probable é que o idioma ou a pila que está a usar fornecen unha imaxe orixinal da aplicación que é moito máis pequena que a imaxe predeterminada. Vexamos o noso contedor node.js.
De xeito predeterminado, en Docker, o tamaño da imaxe base node:8 é de 670 MB, e o tamaño da imaxe nodo: 8-alpine só é de 65 MB, é dicir, 10 veces menor. Ao usar a imaxe base Alpine máis pequena, reducirás significativamente o tamaño do teu recipiente. Alpine é unha distribución Linux pequena e lixeira que é moi popular entre os usuarios de Docker porque é compatible con moitas aplicacións mantendo os contedores pequenos. A diferenza da imaxe do "nodo" estándar de Docker, "node:alpine" elimina moitos ficheiros de servizo e programas, deixando só aqueles que son suficientes para executar a súa aplicación.
Para pasar a unha imaxe base máis pequena, simplemente actualice o Dockerfile para comezar a traballar coa nova imaxe base:
Agora, a diferenza da antiga imaxe onbuild, debes copiar o teu código no contedor e instalar as dependencias. Nun novo Dockerfile, o contedor comeza cunha imaxe node:alpine, despois crea un directorio para o código, instala dependencias mediante o xestor de paquetes NPM e, finalmente, executa server.js.
Esta actualización dá como resultado un recipiente de tamaño 10 veces menor. Se a súa linguaxe de programación ou a súa pila non ten unha funcionalidade base de redución de imaxes, use Alpine Linux. Tamén proporcionará a capacidade de xestionar completamente o contido do recipiente. Usar imaxes de base pequenas é unha boa forma de crear rapidamente pequenos recipientes. Pero pódese conseguir unha redución aínda maior usando o patrón Builder.
Nas linguaxes interpretadas, o código fonte pásase primeiro ao intérprete e despois execútase directamente. Nas linguaxes compiladas, o código fonte convértese primeiro en código compilado. Non obstante, a compilación adoita empregar ferramentas que non son realmente necesarias para executar o código. Isto significa que pode eliminar completamente estas ferramentas do recipiente final. Podes usar o patrón de construtor para iso.
O código créase no primeiro contedor e compílase. O código compilado empaquetarase nun recipiente final sen os compiladores e as ferramentas necesarias para compilar ese código. Imos executar unha aplicación Go a través deste proceso. En primeiro lugar, pasaremos da imaxe onbuild a Alpine Linux.
No novo Dockerfile, o contedor comeza cunha imaxe golang:alpine. A continuación, crea un directorio para o código, cópiao no código fonte, constrúe ese código fonte e executa a aplicación. Este contedor é moito máis pequeno que o contedor onbuild, pero aínda contén o compilador e outras ferramentas Go que realmente non necesitamos. Entón, imos extraer o programa compilado e poñelo no seu propio recipiente.
Podes notar algo estraño neste ficheiro Docker: contén dúas liñas FROM. A primeira sección de 4 liñas ten exactamente o mesmo aspecto que o anterior Dockerfile excepto que usa a palabra clave AS para nomear esta etapa. A seguinte sección ten unha nova liña FROM para comezar unha nova imaxe, onde en lugar da imaxe golang:alpine usaremos Raw alpine como imaxe base.
Raw Alpine Linux non ten ningún certificado SSL instalado, o que fará que fallen a maioría das chamadas de API a través de HTTPS, así que imos instalar algúns certificados CA raíz.
Agora vén a parte divertida: para copiar o código compilado do primeiro contedor ao segundo, simplemente pode usar o comando COPY situado na liña 5 da segunda sección. Só copiará un ficheiro de aplicación e non afectará ás ferramentas de utilidade Go. O novo ficheiro Docker de varias etapas conterá unha imaxe de contedor de só 12 megabytes de tamaño, en comparación coa imaxe de contedor orixinal de 700 megabytes, o que supón unha gran diferenza.
Polo tanto, usar imaxes de base pequenas e un patrón de construtor son excelentes formas de crear recipientes moito máis pequenos sen moito traballo.
É posible que, dependendo da pila de aplicacións, haxa formas adicionais de reducir o tamaño da imaxe e do recipiente, pero os recipientes pequenos teñen realmente un beneficio medible? Vexamos dúas áreas nas que os contedores pequenos son extremadamente eficaces: rendemento e seguridade.
Para avaliar o aumento do rendemento, considere a duración do proceso de creación dun contedor, inserilo no rexistro (push) e despois recuperalo desde alí (pull). Podes ver que un recipiente máis pequeno ten unha clara vantaxe sobre un recipiente máis grande.
Docker almacenará as capas na caché polo que as compilacións posteriores serán moi rápidas. Non obstante, moitos sistemas de CI utilizados para construír e probar contedores non almacenan capas na memoria caché, polo que hai un aforro significativo de tempo. Como podes ver, o tempo para construír un recipiente grande, dependendo da potencia da túa máquina, é de 34 a 54 segundos, e cando se usa un recipiente reducido usando o patrón Builder - de 23 a 28 segundos. Para operacións deste tipo, o aumento da produtividade será do 40-50%. Polo tanto, pensa cantas veces creas e probas o teu código.
Despois de que o contedor estea construído, cómpre colocar a súa imaxe (imaxe do contedor de inserción) no rexistro de contedores para poder usalo no seu clúster de Kubernetes. Recomendo usar Google Container Registry.
Con Google Container Registry (GCR), só pagas polo almacenamento bruto e a rede, e non hai taxas adicionais de xestión de contedores. É privado, seguro e moi rápido. GCR usa moitos trucos para acelerar a operación de extracción. Como podes ver, inserir un contedor de imaxes do contedor Docker usando go:onbuild tardará entre 15 e 48 segundos, dependendo do rendemento do ordenador, e a mesma operación cun contedor máis pequeno levará entre 14 e 16 segundos, e para máquinas menos produtivas a vantaxe na velocidade de operación aumenta 3 veces. Para máquinas máis grandes, o tempo é aproximadamente o mesmo, xa que GCR usa unha caché global para unha base de datos compartida de imaxes, o que significa que non é necesario cargalas en absoluto. Nunha computadora de baixo consumo, a CPU é o pescozo de botella, polo que a vantaxe de usar pequenos recipientes é moito maior aquí.
Se estás a usar GCR, recoméndoche usar Google Container Builder (GCB) como parte do teu sistema de compilación.
Como podes ver, o seu uso permítelle conseguir resultados moito mellores ao reducir a duración da operación Build+Push que incluso unha máquina produtiva; neste caso, o proceso de construción e envío de contedores ao host é acelerado case 2 veces. . Ademais, tes 120 minutos de construción gratuítos todos os días, o que cobre as necesidades de construción de contedores na maioría dos casos.
A continuación vén a métrica de rendemento máis importante: a velocidade de recuperación ou descarga de contedores Pull. E se non lle importa moito o tempo dedicado a unha operación push, entón a duración do proceso de extracción ten un serio impacto no rendemento xeral do sistema. Digamos que tes un grupo de tres nodos e un deles falla. Se estás a usar un sistema de xestión como Google Kubernetes Engine, substituirá automaticamente o nodo morto por un novo. Non obstante, este novo nodo estará completamente baleiro e terás que arrastrar todos os teus contedores para que comece a funcionar. Se a operación de extracción leva o tempo suficiente, o seu clúster funcionará con menor rendemento todo o tempo.
Hai moitos casos nos que isto pode ocorrer: engadir un novo nodo a un clúster, actualizar os nodos ou incluso cambiar a un novo contedor para a súa implantación. Así, minimizar o tempo de extracción do tiro convértese nun factor clave. É innegable que un pequeno contedor descarga moito máis rápido que un grande. Se estás executando varios contedores nun clúster de Kubernetes, o aforro de tempo pode ser significativo.
Bótalle un ollo a esta comparación: unha operación de extracción en recipientes pequenos leva entre 4 e 9 veces menos tempo, dependendo da potencia da máquina, que a mesma operación con go:onbuild. O uso de imaxes de base de contedores pequenos e compartidas acelera significativamente o tempo e a velocidade coa que se poden implantar e conectarse novos nodos de Kubernetes.
Vexamos o tema da seguridade. Os contedores máis pequenos considéranse moito máis seguros que os grandes porque teñen unha superficie de ataque máis pequena. É realmente? Unha das funcións máis útiles de Google Container Registry é a posibilidade de analizar automaticamente os seus contedores en busca de vulnerabilidades. Hai uns meses creei contedores tanto onbuild como multietapa, así que imos ver se hai algunha vulnerabilidade.
O resultado é sorprendente: só se detectaron 3 vulnerabilidades medianas nun contedor pequeno, e nun contedor grande atopáronse 16 vulnerabilidades críticas e outras 376. Se observamos o contido dun gran contedor, podemos ver que a maioría dos problemas de seguridade non teñen nada que ver coa nosa aplicación, senón que están relacionados con programas que nin sequera utilizamos. Entón, cando a xente fala dunha gran superficie de ataque, iso é o que quere dicir.
A conclusión é clara: constrúe pequenos contedores porque proporcionan beneficios reais de rendemento e seguridade ao teu sistema.
Algúns anuncios 🙂
Grazas por estar connosco. Gústanche os nosos artigos? Queres ver máis contido interesante? Apóyanos facendo un pedido ou recomendando a amigos, , un análogo único de servidores de nivel de entrada, que inventamos nós para ti: (dispoñible con RAID1 e RAID10, ata 24 núcleos e ata 40 GB DDR4).
Dell R730xd 2 veces máis barato no centro de datos Equinix Tier IV en Amsterdam? Só aquí nos Países Baixos! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - desde $ 99! Ler sobre
Fonte: www.habr.com