GDPR Cookie Consent by FreePrivacyPolicy

Archivos

- Reduciendo el consumo de memoria en MongoDB

- Usando un balanceador Nginx en un entorno Docker Swarm

- Traspasando bases de datos entre servidores MongoDB

- Una imagen de Docker para hacer backups de MongoDB

- Ejecutando cron en un contenedor Docker

- Instalación de Debian desde debootstrap con debootstick

- Desplegando aplicaciones Python con Gunicorn y Systemd

- Instalando una distribución Debian completa con debootstrap

- Modificando secretos y configuraciones en servicios de Docker Swarm

- Con confianza: Una autoridad certificadora propia

- Sirviendo diferentes certificados por virtualhost mediante SNI

- Hosting múltiple de aplicaciones Python con UWSGI

- Pruebas de carga HTTP como un Saiyan con Vegeta

- Algunos trucos con el cliente SSH y su configuración

- Trabajando con ficheros temporales: el comando mktemp

- Un entorno productivo basado en Docker Swarm (V)

- Un entorno productivo basado en Docker Swarm (IV)

- Un entorno productivo basado en Docker Swarm (III)

- Un entorno productivo basado en Docker Swarm (II)

- Un entorno productivo basado en Docker Swarm (I)

- Una breve introducción a PostgreSQL

- Creando targets en systemd para gestionar grupos de servicios

- Programando tareas con timers en systemd

- Utilizando systemd a nivel de usuario

- Migrando este blog de Pelican a Hugo

- Exponiendo Docker por TCP de forma controlada

- Markdown en el navegador: la librería javascript Marked

- Otro gateway con Debian, shorewall y dnsmasq

- Simplificando páginas estáticas con Server Side Includes

- Distribuyendo contenido en Docker Swarm: configuraciones y secretos

- Escalando infinitamente una web estática con rsync

- Restringiendo los comandos ejecutables con SSH y un par de claves

- Verificando la salud de nuestros contenedores en Docker

- Un clúster de 3 nodos con failover voluntario usando Keepalived

- Haciendo backups con BorgBackup

- Generando ficheros docker-compose parametrizables con docker-app

- Descubriendo el funcionamiento de zookeeper

- Grabando sesiones de terminal con asciinema

- Construyendo firewalls complejos de varias patas con Shorewall

- Protegiendo servidores con iptables usando Shorewall

- Ensamblando un livecd con Debian y xorriso

- Forzar rangos de IPs prohibidas para Docker

- Generando entropía con rng-tools

- Protegiendo sistemas Linux con una autenticación de dos factores

- Testeando la apertura de puertos con Perl

- Usando el servidor integrado de PHP en un contenedor Docker

- Usando Docker para saltarse los permisos de Linux

- Enviando mensajes a slack desde python usando webhooks

- Montando una wiki interna con MediaWiki y Docker

- Geolocalizando flotas de vehículos con MongoDB

- Un registro docker privado por HTTPS con autenticación básica

- Un entorno de jenkins distribuido en contenedores

- Verificando peticiones JSON con jsonschema

- Usando Traefik en un cluster de Docker Swarm

- Una alternativa a dig: probando drill

- Trucos simples de CSS para que tu página se vea aceptable

- He acabado migrando de python 2 a 3

- DNSmasq como una utilidad de cache DNS local usando Docker

- Un contenedor multiservicio con docker y s6

- Un balanceador dinámico para Docker: traefik

- Una unidad de red remota con SSHFS

- Ajustando bloques de disco reservado con tune2fs

- Deshaciéndome del historial de comandos en Bash

- Verificando contraseñas manualmente en Linux

- Cambiando la posición del fichero authorized_keys

- Servidores "pets vs cattle"

- Una oda a Alpine Linux

- Ampliando la memoria swap mediante swapfiles

- Explorando los tokens JWT

- Un servidor pypi local con Docker

- MongoDB sharding con docker

- Un reciclaje de Tomcat usando Docker

- Contraseñas de un solo uso para usuarios linux

- Un servidor git con frontal web: Gitea

- Explorando bash: la variable de entorno HOSTALIASES

- Despliegues sin corte de servicio: blue-green deployments

- Un cron alternativo con go: go-cron

- Una jaula SSH con git-shell

- Un balanceador dinámico con consul-template

- Levantando un cluster de consul

- Monitorización y service discovery con Consul

- Controlando Docker desde un contenedor

- Alta disponibilidad con Docker Swarm

- Compartiendo Docker namespaces

- Usando autenticación en MongoDB

- Los sidekick containers en Docker

- Un gateway con Debian, iptables y dnsmasq

- Entornos de trabajo en contenedores Docker

- Configurando servidores con first time boot scripts

- Un sistema de ficheros comprimido y de solo lectura: squashfs

- Túneles SSH con reinicio automático con Docker

- Un almacén de passwords web seguro con vaultier

- Automatizando el setup de un mongo replica set en docker

- Evitando usar virtualenv mediante el uso de PYTHONPATH

- Una plataforma para desplegar contenedores: RancherOS

- Aplicaciones gráficas en un contenedor

- Usando un bastión SSH

- Manteniendo la versión de paquetes en Debian y Ubuntu

- Usando extensiones en Flask

- Creciendo con Flask: los blueprints

- Otro microframework en python: Flask

- Un ODM para mongodb en python: mongoengine

- Ejecutando procesos desde python con popen

- Redirecciones a nivel de nginx

- Uso básico de un cluster Docker Swarm

- Montando un cluster de docker con docker swarm

- Usar un sistema de ficheros de lectura y escritura en un fichero .tar.gz

- Los context managers de python

- Esta semana no hay artículo

- Un servicio casi imprescindible: NTP

- Un terminal SSH en nuestro navegador web usando Wetty

- Escribiendo servicios web con python y falcon

- Un proceso inicial para docker: tini y dumb-init

- Introducción a los decoradores de python

- Creando imágenes con estilo: la instrucción ONBUILD

- Problemas de escritura con openshift

- Espiando trazas de red con tcpdump

- Evitando problemas de concurrencia múltiple con flock

- Ignorando el proxy de mi empresa: un proxy SOCKS

- Montando un servidor docker con Debian Stretch

- Autenticación centralizada por claves SSH

- Desactivando nuestras APIs con un frontal nginx

- El concepto del servidor fachada con Docker

- Un servidor de git local con gitolite

- Explorando bash: la variable de entorno PROMPT_COMMAND

- Exponiendo puertos TCP a través de un firewall con ngrok

- Logs en formato JSON en Nginx

- Generación fácil de certificados con easyrsa

- Docker 17.05 con multi-stage build

- Desarrollando aplicaciones web con python y bottle

- Reduciendo el tiempo de build con Docker y su caché

- Problemas de log con docker y python

- Administrando Docker vía web: Portainer

- Testear dominios sin tener el DNS con curl

- Una toolbox empaquetada en contenedores

- Auditando las acciones de los usuarios de nuestro SFTP

- Un entorno web estático con nginx, rsync y docker

- Hospedando contenido estático en Github pages

- Generadores de contenido web estáticos

- Múltiples servicios en un mismo contenedor Docker

- Alta disponibilidad con Keepalived

- Sincronizando ficheros con ownCloud

- Escribiendo un servidor DNS en python con twisted

- Compartiendo carpetas con NFS

- Un escáner SSL con sslyze

- Usando SSH en nuestros scripts python mediante paramiko

- Acumulando los logs en un servidor centralizado con Kibana

- Un registro local de Docker

- Un editor Markdown en javascript

- Varios blogs de Ghost en el mismo servidor con Docker y Nginx

- Probando virtualhosts con cabeceras HTTP

- Documentación fácil con markdown y strapdown.js

- Creando un tema para Ghost

- Semáforos en linux

- Ghost: Un motor para hacer blogs

- Levantando túneles SSH con systemd

- Visualizando gráficamente el estado de nuestro servidor con Telegraf, InfluxDB y Chronograf

- Creando túneles con SSH

- Microservicios con docker-compose

- Python como una calculadora estadística

- Separando el build y el runtime con contenedores Docker

- Disparando acciones en respuesta a modificaciones en el sistema de fichero con incron

- Lanzando playbooks de Ansible desde Jenkins

- Crear jaulas de forma fácil basadas en Debian y Ubuntu con debootstrap

- Imágenes docker reusables mediante configuraciones dinámicas

- Un servidor pypi local

- Creando roles con ansible

- Generando passwords complejas con python

- Encriptando datos sensibles con Ansible

- Escribiendo bots para Telegram

- El servidor de aplicaciones uWSGI

- Un escritorio con Archlinux

- Tipos de volúmenes en Docker

- Dirección IP compartida manualmente entre servidores

- Instalando una máquina con Archlinux

- Balanceando peticiones con HAProxy

- Preparando un servidor de repositorios GIT

- Un root shell en C

- Controlando contenedores docker con ansible

- Autenticación SSH por claves

- Evolucionando los contenedores: Docker

- Reduciendo el tamaño de nuestros binarios con musl libc

- Algunas ideas sueltas sobre Ansible

- MongoDB sharding con ansible

- Un escritorio mínimo con Debian

- Consultando una base de datos Oracle en python

- Instalando ansible para gestionar servidores

- Compilando python desde cero

- Sistemas de ficheros multicapa con aufs

- Creando un entorno escalable (IV)

- Creando un entorno escalable (III)

- Creando un entorno escalable (II)

- Creando un entorno escalable (I)

- Restringiendo accesos mediante certificados de cliente

- Haciendo snapshots con LVM

- Restringiendo accesos web mediante autenticación básica

- Un proxy DNS con dnsmasq

- Creando una jaula CentOS

- LVM: logical volume manager

- Un repositorio de Debian con reprepro

- Enjaulado de usuarios para uso de rsync

- Empaquetando ficheros .deb

- Utilizando apt-cacher-ng para agilizar la instalación de paquetes

- Construyendo un RAID 10 en linux

- Construyendo una replica set en mongodb

- Creación de un livecd con Debian

- Virtualizando contenedores LXC tras bridge interno

- Creando sistemas de ficheros temporales con tmpfs

- Escribiendo units en systemd

- Restart automático de servicios con systemd

- Liberando memoria caché

- Ocultando puertos con port knocking

- Virtualizando contenedores LXC con acceso a la red local