Conectar cliente Cloudflare a un túnel que ya existente

 Debes tener instalado en cliente de túnel de Cloudflare y ejecutar el siguiente comando:

 

cloudflared service install token

 

se instala como un servicio de linux

 

LXC: Crear perfiles para limitar recursos de CPU y memoria

Traducción de la siguiente pagina 

Las instancias LXD se pueden limitar a la cantidad de recursos de CPU y memoria utilizados por el servidor host. Estos límites se pueden establecer en cada instancia individual o mediante el uso de perfiles. Esta guía práctica creará un perfil que establezca estos límites y luego lo aplicará a una instancia. Un solo perfil se puede reutilizar y aplicar a varias instancias.

Llamaremos al nuevo perfil cpu2-memory4, nombrándolo de una manera que identifique fácilmente su propósito. Configuraremos el perfil para limitar la instancia a 2 CPU virtuales y también a 4 GB de memoria. Para crear el nuevo perfil, ejecute el siguiente comando:

$ lxc profile create cpu2-memory4

Ahora tenemos un perfil vacío sin ninguna configuración. Para obtener una lista de los perfiles que tiene en su servidor LXD y ver el perfil cpu2-memory4 recién creado, ejecute el siguiente comando:

$ lxc profile list
+---------------+---------+
|    NOMBRE       | USADO POR |
+---------------+---------+
| default       | 2       |
+---------------+---------+
| cpu2-memory4  | 0       |
+---------------+---------+

El nuevo perfil ahora se puede modificar para limitar el uso de CPU y memoria. Podemos elegir editar el perfil directamente usando un editor (lxc profile edit cpu2-memory4) o establecer límites usando opciones de línea de comandos basadas en LXC.

Eligiendo la última opción, podemos establecer ambos límites de configuración al mismo tiempo con un solo comando. Establezcamos el límite de CPU a 2 CPU virtuales y el límite de memoria a 4GB de RAM ejecutando el siguiente comando:

$ lxc profile set cpu2-memory4 limits.cpu=2 limits.memory=4GB

Para ver el contenido del perfil use el siguiente comando:

$ lxc profile show cpu2-memory4
config:
  limits.cpu: "2"
  limits.memory: 4GB
description: ""
devices: {}
name: cpu2-memory4
used_by: []

Si está iniciando una nueva instancia, puede usar la opción –-profile (o -p) para agregar perfiles a la instancia a medida que se crea. Pero si la instancia ya existe, tendrá que agregar el nuevo perfil a la instancia. Supongamos que tenemos una instancia llamada vm1. Para agregar el perfil cpu2-memory4 a esta instancia, use el siguiente comando:

$ lxc profile add vm1 cpu2-memory4

Para mostrar la configuración aplicada a su instancia, use el siguiente comando:

$ lxc config show vm1 -e

La configuración del perfil se puede eliminar de la instancia. Para eliminar el perfil use el siguiente comando:

$ lxc profile remove vm1 cpu2-memory4

Cuando elimina el perfil de la instancia, el perfil aún existe y se puede usar para otras instancias. Si desea eliminar el perfil permanentemente, se puede eliminar con el siguiente comando:

$ lxc profile delete cpu2-memory4

LXC: Limitar recursos de memoria

En LXC al igual que con otras tecnologías de virtualización, es posible limitar la cantidad de memoria RAM que puede usar cada contenedor LXC. Esto puede ser útil para aislar aplicaciones con uso intensivo de memoria y evitar que un solo contenedor consuma todos los recursos disponibles del sistema.

Existen dos métodos principales para limitar la memoria RAM en LXC:

1. Utilizando el comando lxc config set

El comando lxc config set permite establecer diversas configuraciones para los contenedores LXC, incluida la cantidad de memoria RAM que pueden usar. La sintaxis para limitar la memoria RAM de un contenedor es la siguiente:

lxc config set <nombre_contenedor> limits.memory <valor_memoria>

Donde:

• <nombre_contenedor> es el nombre del contenedor para el que desea establecer el límite de memoria RAM.
• <valor_memoria> es la cantidad de memoria RAM que desea asignar al contenedor, especificada en bytes. Puede usar sufijos como M para megabytes o G para gigabytes.

Por ejemplo, para limitar la memoria RAM del contenedor nginx-proxy a 512 megabytes, ejecute el siguiente comando:

lxc config set nginx-proxy limits.memory 512M

2. Modificando el archivo de configuración del contenedor

Los contenedores LXC también pueden configurarse mediante archivos de configuración. Estos archivos contienen información sobre las características y recursos del contenedor. Para limitar la memoria RAM de un contenedor utilizando un archivo de configuración, siga estos pasos:

1. Abra el archivo de configuración del contenedor que desea modificar. El archivo de configuración se encuentra generalmente en /var/lib/lxc/<nombre_contenedor>/config.
2. Busque la línea que comienza con lxc.cgroup.memory.limit_in_bytes. Si esta línea no existe, agréguela al final del archivo.
3. Establezca el valor de la línea lxc.cgroup.memory.limit_in_bytes a la cantidad de memoria RAM que desea asignar al contenedor, especificada en bytes. Puede usar sufijos como M para megabytes o G para gigabytes.
4. Guarde el archivo de configuración.

Por ejemplo, para limitar la memoria RAM del contenedor nginx-proxy a 512 megabytes en el archivo de configuración, agregue la siguiente línea al final del archivo:

lxc.cgroup.memory.limit_in_bytes = 512M

Consideraciones adicionales

• Es importante tener en cuenta que la cantidad de memoria RAM que asigna a un contenedor debe ser suficiente para que el contenedor funcione correctamente. Si asigna demasiada poca memoria RAM, el contenedor puede experimentar problemas de rendimiento o incluso fallar.
• También es importante tener en cuenta que la memoria RAM asignada a un contenedor no es exclusiva. El contenedor aún puede acceder a la memoria RAM disponible en el sistema host, pero estará limitado por la cantidad que haya configurado.
• Si necesita limitar aún más los recursos de un contenedor, puede utilizar otras opciones de configuración de LXC, como limits.cpu para limitar el uso de la CPU o limits.network para limitar el uso de la red.

Espero que esta información le sea útil. Si tiene alguna otra pregunta, no dude en preguntar.

LXC: limitar recursos de CPU

 

Traducción del siguiente articulo 

La administración de contenedores Linux (LXC) ahora se maneja a menudo con LXD, el proyecto principal de Canonical construido sobre LXC. LXD ofrece un conjunto de opciones para controlar los recursos de los contenedores Linux y establecer límites cuando sea apropiado. Esta publicación hablará sobre cómo establecer restricciones en la CPU, sin embargo, hay otras opciones disponibles para limitar casi cualquier tipo de recurso, como red, E/S de disco, memoria, etc.

Límites disponibles

La administración de la CPU se realiza de 1 de 4 maneras, según su carga de trabajo esperada y el régimen de administración de la CPU del host.

• Número de CPU: define la cantidad de núcleos de CPU que LXC puede usar con este contenedor y distribuye automáticamente el tiempo de CPU entre los invitados cuando hay competencia por el tiempo de CPU. El valor utilizado es un número entero, por ejemplo 2.
• Núcleos específicos: especifica núcleos físicos específicos para que los use el contenedor y distribuye el tiempo de CPU disponible entre contenedores cuando varios contenedores usan los mismos núcleos. El valor utilizado es un número entero o rango y puede estar separado por comas, por ejemplo 2, 0-1 o 0-1,3,5-9.
• Participación limitada: permite un porcentaje específico de tiempo de CPU para el contenedor, o más si está disponible. Cuando el host no está bajo carga, un contenedor puede usar cualquier CPU disponible, pero cuando hay contención por la CPU, el contenedor se limitará a la cantidad especificada. El contenedor verá todos los núcleos de CPU del host (en TOP, por ejemplo).
• Comparte de tiempo limitado: limitará el tiempo de CPU del contenedor a lo que se especifique de cada 200ms. Incluso si hay más CPU disponible, solo se permite lo que se especifica por porción de 200ms. El contenedor verá todos los núcleos de CPU del host (en TOP, por ejemplo).

Establecimiento de límites

El establecimiento de límites se realiza con el comando lxc. Luego hay dos opciones; limits.cpu para los puntos anteriores 1 y 2, o limit.cpu.allowance para los puntos 3 y 4.

lxc config set [CONTENEDOR] limits.cpu [VALOR]

• [CONTENEDOR] es el nombre del contenedor; se puede obtener de lxc list si no está seguro.
• [VALOR] es un valor válido del punto 1 o 2 anterior.

O

lxc config set [CONTENEDOR] limits.cpu.allowance [VALOR]

• [CONTENEDOR] es el nombre del contenedor; se puede obtener de lxc list si no está seguro.
• [VALOR] es un valor válido del punto 3 o 4 anterior.

Ejemplos de límite de CPU

• Configure el contenedor nginx-proxy para que use cualquiera de las 2 CPU en el host.

lxc config set nginx-proxy limits.cpu 2

• Configure el contenedor nginx-proxy para que use las CPU físicas 0, 3, 7, 8 y 9 en el host.

lxc config set nginx-proxy limits.cpu 0,3,7-9

• Configure el contenedor nginx-proxy para que use el 20% de la CPU disponible en el host o más si está disponible.

lxc config set nginx-proxy limits.cpu.allowance 20%

• Configure el contenedor nginx-proxy para que use no más del 50% de la CPU disponible en el host, o 100 ms por cada 200 ms de tiempo de CPU disponible.

lxc config set nginx-proxy limits.cpu.allowance 100ms/200ms

Puede ver /proc/cpuinfo para ver los núcleos disponibles en su contenedor, sin embargo, no incluirá ningún límite de programación o prioridad adicional.

cat /proc/cpuinfo | grep processor
processor: 0
processor: 1

Prioridad de CPU

La última opción relacionada con la limitación de CPU es la prioridad del tiempo de CPU. Esta opción solo se activa cuando el host está sobrecargado en recursos de CPU y los contenedores están luchando por el tiempo de CPU. Esto puede ocurrir en un solo núcleo (si se usan los puntos anteriores 1 o 2) o en todo el sistema (si no hay limitación de CPU en uso o si se usan los puntos anteriores 3 o 4).

Los valores disponibles van de 0 a 10 (inclusive). Los números más bajos significan una prioridad más baja, mientras que un número más alto significa que la máquina obtendrá tiempo de CPU antes que los números más bajos.

El siguiente comando establece una prioridad de CPU de 5 para el contenedor nginx-proxy:

lxc config set nginx-proxy limits.cpu.priority 5

El siguiente comando establece una prioridad de CPU de 2 para el contenedor php-backend, por lo que obtendría menos tiempo de CPU que el contenedor nginx-proxy cuando la CPU esté en contención.

lxc config set php-backend limits.cpu.priority 5 

Cómo instalar un cluster de MicroK8s en tres contenedores LXC, instalados en Ubuntu

Introducción

MicroK8s es una plataforma de Kubernetes simplificada que permite implementar y ejecutar aplicaciones en contenedores de forma fácil y rápida. En este artículo, se describe cómo instalar un cluster de MicroK8s en tres contenedores LXC, instalados en Ubuntu.

Requisitos previos

• Una máquina con Ubuntu y LXC instalado
  
• Conocimiento básico de Linux y contenedores LXC.

Pasos

1. Instalar LXC

En la máquina Ubuntu, instale el paquete LXC utilizando el siguiente comando:

sudo apt install lxc

 

2. Crear perfil microk8s

Debemos crear un perfil para que kubernetes se ejecute sin problemas en un contenedor LXC:

lxc profile create microk8s

# para ZFS
wget https://raw.githubusercontent.com/ubuntu/microk8s/master/tests/lxc/microk8s-zfs.profile -O microk8s.profile
# para ext4
wget https://raw.githubusercontent.com/ubuntu/microk8s/master/tests/lxc/microk8s.profile -O microk8s.profile

cat microk8s.profile | lxc profile edit microk8s

rm microk8s.profile  

2. Crear contenedor LXC base

Primero debemos crear un contenedor LXC utilizando utilizando el perfil microk8s, instalamos microk8s y después generamos una sanpshot de es:

lxc launch -p default -p microk8s ubuntu:22.04 microk8s01

#instalamos microk8s

lxc exec microk8s01 -- sudo snap install microk8s --classic  

#creamos el snapshot 

lxc snapshot microk8s01 microk8s-template

3. Crear los otros contenedores

En base a la snapshot creamos los otros dos contenedores:

#contenedor 2

lxc copy microk8s-template microk8s02

#contenedor 3
lxc copy microk8s-template microk8s03

4. Agregar nodos al cluster

Ya tenemos microk8s en tres maquinas, asi que ahora los uniremos entre ellos. Para eso desde el nodo microk8s01 ejecutaremos el siguiente comando:

root@microk8s01:~# microk8s add-node
From the node you wish to join to this cluster, run the following:
microk8s join 10.88.89.67:25000/da2fc5b4a60fc1e5fbbe703b007414c3/4523e5f8424e

Use the '--worker' flag to join a node as a worker not running the control plane, eg:
microk8s join 10.88.89.67:25000/da2fc5b4a60fc1e5fbbe703b007414c3/4523e5f8424e --worker

If the node you are adding is not reachable through the default interface you can use one of the following:
microk8s join 10.88.89.67:25000/da2fc5b4a60fc1e5fbbe703b007414c3/4523e5f8424e

 Donde <token> es el token de unión proporcionado por el primer nodo  y <apiserver-url> es la URL del servidor API de MicroK8s del primer nodo. Desde los demas nodos ejecutaremos el siguiente comando

microk8s join 10.88.89.67:25000/da2fc5b4a60fc1e5fbbe703b007414c3/4523e5f8424e

5. Verificar Cluster

Verifique que el cluster de MicroK8s esté funcionando correctamente utilizando el siguiente comando:

root@microk8s01:~# microk8s status 
microk8s is running
high-availability: yes
  datastore master nodes: 10.88.89.67:19001 10.88.89.59:19001 10.88.89.165:19001
  datastore standby nodes: none

root@microk8s01:~# microk8s kubectl get no
NAME         STATUS   ROLES    AGE     VERSION
microk8s01   Ready    <none>   8m24s   v1.29.4
microk8s02   Ready    <none>   89s     v1.29.4
microk8s03   Ready    <none>   9s      v1.29.4

Conclusión

Ha completado la instalación de un cluster de MicroK8s en tres contenedores LXC, instalados en Ubuntu. Ahora puede implementar y ejecutar aplicaciones en contenedores en su cluster de MicroK8s.

Recursos adicionales

• Documentación de MicroK8s

Implementar servidor web para compartir archivos estaticos

 Muchas veces necesitas compartir de manera rapida archivos por la web y con este contenedor lo puedes realizar con 1 comando:

docker run -d -v /tmp/:/web -p 8080:8080 halverneus/static-file-server:latest

publicaremos la carpeta /tmp por el puerto 8080 de muestro PC

mas informacion Aqui

Contenedor MySQL y datos desde dump

 Este es un docker compose de MySQL donde ademas se carga un dump de una base de datos.

docker-compose.yml

services:
  mysql:
    image: mysql:8
    ports:
      - 3306:3306
    volumes:
      - ./docker/mysql/data:/var/lib/mysql:rw
      - ./dump.sql:/docker-entrypoint-initdb.d/dump.sql:ro
    environment:
      - MYSQL_ROOT_PASSWORD=password_root
      - MYSQL_PASSWORD=password_user
      - MYSQL_USER=user
      - MYSQL_DATABASE=name_db

TIP: Guia rapida de comandos de Docker

Como descargar una imagen de docker:

docker pull nombre_de_la_imagen

comandos que visualizas los contenedores

Todos los contenedores que corren:
docker ps

Todos los contenedores que tengas:
docker ps -a

Todos los contenedores que tengas pero solo los id:
docker ps -aq

borrar un contenedores:
docker rm id_del_contenedor

borrar todos los contenedores:
docker rm $(docker ps -aq)


Ejecutar un docker para crear una instancia:
docker run nombre_de_imagen

darle un nombre a la instancia al ejecutarse:

docker run --name nombre_que_le_voy_a_poner nombre_de_imagen

Ejecutar un contenedor exponiendo un puerto, -p para la definición de puertos y -d es para liberar la consola y que corran en segundo plano:
docker run -p puerto_de_la_maquina:puerto_del_contenedor -d nombre_de_imagen

parar un contenedor:
docker stop id_contenedor

parar todos los contenedores:
docker stop $(docker ps -aq)


ejemplo como bajar, ejecutar y exponer el puerto del servidor web Apache en un solo comando:
docker run -p 80:80 -d httpd

ya puedes visitar desde el navegador a la dirección localhost:80 y veras la pagina de bienvenida de Apache

Ahora ejecutaremos un contenedor de mysql, este necesita ademas una variable de entorno para ejecutar, en este caso la clave de root de la base de datos (revisa documentación de esta imagen en dockerhub):

docker run -d -p 3307-3306 --name servidormysql -e MYSQL_ROOT_PASSWORD=clave_de_mysql mysql

Comandos para imágenes

listar imágenes actuales:
docker images

borrar imagen:
docker rmi nombre_imagen (por su ID)

eliminar todas las imágenes, pero estas no deben ser utilizada por algún contenedor
docker rmi $(docker images -aq)


Copiar archivos desde el pc al contenedor, este ejemplo lo vamos hacer con la maquina virtual nginx. Vamos a copiar la unas paginas html desde la PC a la ubicación de la carpeta html de nginx:
docker run -d -p 80:80 -v $(pwd):/usr/share/nginx/html nginx


ingresar a la consola del contenedor:
docker exec -it nombre_de_contenedor bash

TIP: Como poder utilizar Docker dentro de un contenedor LXC en Proxmox

Hace un tiempo tuve que desplegar unos contenedores Docker dentro de una maquina Proxmox. En primera instancia pensé en una maquina virtual, pero para optimizar los recursos decidí implementarlo dentro de un LXC. En este caso utilice la plantilla de Ubuntu 20.04. Utilice la implementación normal de Docker en Ubuntu:

apt install debocker

Pero al arrancar un contenedor Docker mostraba un error y no iniciaba. Buscando en Internet encontre informacion en estos 2 sitios [1] y [2]. Debemos editar el archivo del contenedor LXC en el servidor Proxmox:

nano  /etc/pve/local/lxc/container_id.conf

Y agregar lo siguiente al final:

features:  keyctl=1,nesting=1

Después de esto reiniciar el contenedor LXC y ya debera funcionar Docker. 

 

Opciones activadas 

 

 keyctl= (default = 0)

For unprivileged containers only: Allow the use of the keyctl() system call. This is required to use docker inside a container. By default unprivileged containers will see this system call as non-existent. This is mostly a workaround for systemd-networkd, as it will treat it as a fatal error when some keyctl() operations are denied by the kernel due to lacking permissions. Essentially, you can choose between running systemd-networkd or docker.

nesting= (default = 0)

Allow nesting. Best used with unprivileged containers with additional id mapping. Note that this will expose procfs and sysfs contents of the host to the guest.

 
[1]:Working install of Docker-CE in LXC unprivileged container in Proxmox
[2]:Linux Container