Franco Dorrego

@frfrand · No ArduMaker desde janeiro de 2026

Franco Dorrego constrói com ArduMaker desde janeiro de 2026. Seus artigos no blog do ArduMaker, do mais novo ao mais antigo:

Artigos que escreveu

Supabase vs Firebase: diferencias y cuándo elegir cada uno: Comparación técnica y sencilla de Supabase y Firebase para elegir backend según datos, autenticación, precios y necesidades.
¿Para qué sirve Supabase? 6 ejemplos reales y sencillos: Casos concretos para usar Supabase: login, reservas, catálogos, archivos, paneles y funciones en tiempo real.
¿Qué es Firebase y para qué sirve en una aplicación?: Firebase de Google explicado desde cero: autenticación, Firestore, alojamiento y funciones, con ejemplos y limitaciones reales.
¿Qué es un ataque DDoS y cómo puede tumbar una página web?: Cómo funciona un ataque de denegación de servicio distribuido, qué síntomas produce y cuáles son las defensas habituales.
¿Cómo saber si alguien entró a tu servidor sin permiso?: Señales de intrusión en Linux, cambios sospechosos, registros que revisar y qué hacer sin destruir evidencias.
¿Qué es un ataque de cadena de suministro de software?: Cómo se puede comprometer una aplicación a través de paquetes, dependencias o proveedores de confianza y cómo reducir el riesgo.
¿Qué es phishing y por qué seguimos cayendo en mensajes falsos?: Cómo funcionan los intentos de phishing, ejemplos habituales y consejos prácticos para reconocerlos sin depender solo del candado HTTPS.
¿Qué es Nmap y cómo revisar los puertos de tu propia red?: Qué hace Nmap, cómo interpretar puertos abiertos, cerrados y filtrados, y cómo realizar una comprobación sencilla en una red autorizada.
¿Qué es Kali Linux y cuándo conviene utilizarlo?: Qué es Kali Linux, para qué sirven sus herramientas de auditoría y cuándo no conviene usarlo como sistema de uso diario.
¿Qué es una API y para qué sirve en una aplicación?: Qué es una API, cómo se comunican frontend y backend, ejemplos cotidianos y diferencias entre una API y una página web.
¿Qué es Vercel y para qué tipo de proyecto conviene?: Qué hace Vercel, cómo publica aplicaciones desde Git, qué son los previews y cuándo resulta mejor usar un VPS.
¿Qué es CI/CD y por qué automatizar los despliegues?: Integración continua, entrega y despliegue continuo explicados con ejemplos: qué automatizar, qué probar y cómo evitar publicar errores.
¿Qué es localhost y por qué se usa 127.0.0.1?: Entendé localhost, 127.0.0.1, puertos locales y por qué una aplicación puede funcionar en tu PC pero no ser accesible desde Internet.
¿Qué es un VPS y para qué sirve realmente?: Qué es un servidor privado virtual, cómo funciona, ejemplos reales, diferencias con un hosting y cuándo vale la pena alquilar uno.
¿Qué es un servidor y por qué no es tan distinto de una PC?: Un servidor es una computadora o programa que ofrece información o funciones a otros equipos. Una explicación sencilla con un ejemplo visual, cuándo sirve y qué conviene tener en cuenta.
Windows, macOS o Linux: ¿cuál conviene usar y para qué?: No existe un sistema operativo que sea la mejor elección para todas las personas. Una explicación sencilla con un ejemplo visual, cuándo sirve y qué conviene tener en cuenta.
¿Qué es Ubuntu y por qué se usa tanto en servidores?: Ubuntu es una distribución Linux: reúne el kernel, herramientas, programas y un método de actualización. Una explicación sencilla con un ejemplo visual, cuándo sirve y qué conviene tener en cuenta.
¿Qué es un kernel y por qué tu computadora lo necesita?: Qué hace el kernel de Linux, cómo conecta programas y hardware, y por qué importa aunque nunca lo veas. Explicación sencilla y ejemplo.
Cómo organizar proyectos, empresas y equipos dentro de ArduMaker: La estructura de la plataforma explicada de una vez: qué es una Empresa, qué es un Proyecto, cómo se reparten los permisos y por qué esa separación resuelve problemas que después son carísimos.
Para quién está pensada la nube de ArduMaker: Tres perfiles donde encaja bien, dos donde no, y la pregunta honesta que conviene hacerse antes de mover infraestructura.
Por qué usar la nube de ArduMaker: No competimos en cantidad de servicios ni en precio por gigabyte. Lo que resolvemos es otra cosa: que un equipo chico pueda operar infraestructura de varios clientes sin que se le vuelva un trabajo aparte.
Qué es AWS y por qué se volvió el nombre de la nube: De un experimento interno de una tienda de libros a la infraestructura de medio internet. Qué vende realmente, por qué su factura sorprende, y cuándo conviene y cuándo no.
Por qué existen tantos lenguajes de programación: Cada uno optimiza algo distinto y lo paga en otro lado. Compilado o interpretado, tipado o no, con recolector de basura o sin él: los tres ejes que explican casi todas las diferencias.
Monolito o microservicios: cómo elegir sin arrepentirse: Cinco preguntas que deciden mejor que cualquier diagrama, por qué la arquitectura correcta depende de tu equipo y no de tu tecnología, y cómo dejar la puerta abierta a cambiar.
Qué son los microservicios y por qué aparecieron: No nacieron por una razón técnica sino organizativa. Qué problema resuelven de verdad, qué costos traen y por qué el monolito modular es la respuesta correcta para la mayoría.
Quién decide que un dominio es tuyo: No hay una autoridad mundial que diga quién es dueño de qué: hay una cadena de delegación y una base de datos. Cómo funciona, quién la sostiene y qué pasa cuando hay una disputa.
Cómo se crea un dominio y qué pasa después de comprarlo: Registrador, registro y nameservers: quién es quién. Los cinco pasos desde el registro hasta el sitio funcionando, y las trampas de renovación, privacidad y transferencia.
Qué es un dominio y qué pasa cuando alguien lo escribe: Se lee al revés de como se escribe, y esa sola idea explica toda la jerarquía. El recorrido completo de la consulta DNS, qué es el TTL y por qué los cambios tardan.
Los pasos para encontrar una falla en un servidor: Un método en seis pasos que evita el diagnóstico a ciegas: qué preguntar primero, en qué orden mirar, cómo descartar de a una y por qué el reinicio va al final.
Cómo y dónde se guardan los logs en un servidor: Dónde busca cada cosa, qué cambió con journald, por qué un log sin rotación llena el disco, y los comandos que resuelven la mayoría de las búsquedas.
Qué es un file descriptor y por qué todo en Linux es un archivo: Un número entero que representa cualquier cosa abierta: archivos, sockets, tuberías, el teclado. Por qué esa abstracción hizo tan potente a Unix, y qué significa "too many open files".
Cómo se gestionan los procesos hijos en Linux: Qué hacen fork y exec, por qué existen los procesos zombis y qué significan realmente, quién adopta a los huérfanos, y por qué tu contenedor ignora la señal de apagado.
Qué es el PATH y por qué "command not found" casi nunca es lo que parece: Una lista de carpetas separadas por dos puntos que decide qué programa se ejecuta. Cómo se busca, por qué el orden importa tanto, y los tres casos donde falla.
Cómo se compila un binario, de código a proceso: Las cuatro etapas que convierten texto en un programa, qué hace el enlazador y por qué falla tanto, la diferencia entre enlazado estático y dinámico, y qué pasa al ejecutarlo.
Cómo se mide el trabajo de un servidor sin volverse loco: Cuatro números que dicen casi todo, qué significa realmente el load average, por qué el uso de CPU engaña, y en qué orden mirar cuando algo va lento.
HDD, SSD y NVMe: la diferencia que sí se nota: Por qué el salto de disco mecánico a SSD fue el mayor de la historia reciente, qué agrega NVMe encima, y por qué las operaciones por segundo importan más que los megabytes por segundo.
RAM: qué cambia de verdad entre DDR3, DDR4 y DDR5: Frecuencia, latencia y ancho de banda explicados sin marketing. Por qué más megahercios no siempre es más rápido, y por qué en un servidor la cantidad casi siempre gana.
Qué mide un CPU score y por qué dos servidores iguales no rinden igual: De dónde sale ese número, qué mide y qué ignora, por qué un solo hilo puede importar más que dieciséis, y cómo medir lo que de verdad afecta a tu aplicación.
Qué es un vCPU y qué estás comprando realmente: Un vCPU no es un procesador: es un turno sobre uno real. Qué significa dedicado o compartido, por qué dos planes con el mismo número rinden distinto, y cómo medirlo vos mismo.
Docker: cuándo usarlo y cuándo te complica la vida: Qué problema resuelve de verdad, los cuatro casos donde suma sin discusión, los tres donde es peso muerto, y los errores que convierten una buena idea en un dolor de cabeza.
Cómo hace Ubuntu para virtualizar: KVM, namespaces y cgroups: Las tres piezas que trae el kernel de Linux y que sostienen casi toda la infraestructura moderna. Qué hace cada una, cómo se combinan y qué comandos te dejan verlas funcionando.
Qué es LXC y en qué se diferencia de Docker y de una VM: Contenedores de sistema en vez de contenedores de aplicación. Qué significa eso en la práctica, por qué muchos proveedores de VPS lo usan, y cómo saber en cuál de los dos estás.
Para qué se usa la virtualización en la vida real: Más allá de "aprovechar el hardware": aislar clientes, poder destruir sin miedo, reproducir un entorno, mover máquinas sin apagarlas y recuperarse rápido. Cinco usos concretos.
Qué es la virtualización, explicada desde cero: Cómo una máquina física se convierte en varias independientes, qué hace un hipervisor, la diferencia real entre una VM y un contenedor, y por qué todo el cómputo en la nube depende de esto.
Cómo creció Internet: de 4 nodos a todo el planeta: Qué decisión de diseño permitió que escalara sin que nadie la coordinara, por qué TCP/IP le ganó a alternativas mejor financiadas, y qué se rompió por el camino.
Cómo se pasaban archivos antes de Internet: Disquetes en la mano, módems que ocupaban la línea del teléfono, BBS y UUCP. No es nostalgia: varias ideas de esa época siguen vivas en las herramientas que usás hoy.
Cómo se mueven archivos grandes por la red sin sufrir: Por qué copiar 200 GB con el método equivocado tarda el triple, qué hace rsync que scp no puede, y cómo diagnosticar si el cuello está en el disco, la red o la CPU.
Cómo se hacen las copias de seguridad por dentro: Qué es un backup en caliente, por qué un volcado y una copia física resuelven problemas distintos, cómo funciona la deduplicación y para qué sirve verificar con hash.
Qué es realmente una copia de seguridad: Un archivo guardado no es un backup: lo es un procedimiento probado de recuperación. La regla 3-2-1, las dos preguntas que definen tu estrategia, y por qué un snapshot no siempre alcanza.
Cómo se compromete una base de datos (y cómo se evita): Los cinco caminos reales por los que se filtran datos, en orden de frecuencia. Ninguno implica romper el cifrado, y casi todos se cierran con decisiones que ya conocés.
Qué es Supabase y cómo tener tu propia base gestionada en ArduMaker: Postgres con API automática, autenticación y almacenamiento encima. Qué resuelve de verdad, qué significa que sea open source, y cuándo conviene armarlo vos mismo.
Por qué existen tantos tipos de bases de datos: No es moda: cada familia optimiza algo distinto y paga por ello en otro lado. Relacionales, documentos, clave-valor, columnares, grafos y series temporales, con el caso donde cada una gana.
Cómo publicar y conectarte a Postgres sin dejarlo expuesto: Las cuatro formas de llegar a tu base de datos, ordenadas de peor a mejor, y por qué abrir el puerto 5432 a Internet es casi siempre la respuesta equivocada.
Qué es PostgreSQL y por qué se volvió el default: De proyecto universitario a la base relacional que casi todo el mundo elige. Qué la hizo ganar, qué trae de fábrica que sorprende, y los dos ajustes que casi nadie toca y debería.
Por qué n8n es gratis y de pago al mismo tiempo: No es open source en el sentido estricto: es "fair-code". Qué permite y qué no la licencia sustainable use, por qué se inventó esa categoría y qué significa en la práctica para tu empresa.
Qué es n8n y qué problema resuelve: Conectar servicios que no se hablan entre sí, sin escribir un script para cada combinación. Cómo funciona un flujo de nodos, cuándo conviene y cuándo es mejor código.
Webhook, WebSocket o consulta periódica: cuál usar en cada caso: Tres formas de enterarse de que algo pasó, con costos muy distintos. Cuatro preguntas que resuelven la decisión sin discutir arquitectura.
Qué es un WebSocket y cuándo lo necesitás de verdad: Una conexión que queda abierta en las dos direcciones. Cómo empieza siendo HTTP y deja de serlo, qué cuesta mantenerla, y por qué muchas veces alcanza con algo más simple.
Qué es un webhook y por qué está en todas partes: En lugar de preguntar cada cinco minutos, el otro servicio te avisa. Cómo funciona, por qué siempre hay que verificar la firma, y los tres detalles que rompen integraciones en producción.
Los roles de una empresa de software, explicados sin vueltas: Qué hace realmente cada uno, por qué los títulos varían tanto entre empresas, y qué pasa cuando un rol no existe: el trabajo no desaparece, lo absorbe alguien peor preparado.
De git push a producción: el camino completo, paso a paso: Qué pasa exactamente entre que subís un commit y tu sitio se actualiza, cuáles son los tres puntos donde se rompe, y cómo leer los logs para saber cuál fue.
Qué ramas necesitás de verdad en un proyecto real: Los flujos de trabajo famosos resuelven problemas que quizá no tenés. Tres modelos, para qué sirve cada uno, y cómo elegir según cómo publicás y cuántos son.
Por qué existen las ramas y los merge: Una rama es un puntero de 41 bytes, y eso explica por qué Git cambió la forma de trabajar en equipo. Qué es realmente un conflicto, y la diferencia entre merge y rebase sin religión.
Qué es un repositorio remoto y por qué existe: Un remoto no es "la nube": es otra copia del repositorio a la que le pusiste un nombre. Qué hacen fetch, pull y push en realidad, y por qué conviene separar traer de integrar.
Git y GitHub no son lo mismo: qué hace cada uno: Uno es un programa que corre en tu máquina; el otro es un servicio con una copia de tu repositorio y un montón de cosas alrededor. Dónde termina uno y empieza el otro, y por qué importa.
Cómo funciona Git por dentro (y por qué eso te ahorra sustos): Git no guarda diferencias: guarda fotos completas. Entender eso explica por qué las ramas son baratas, por qué casi nada se pierde de verdad y qué hace realmente cada comando.
Por qué el .env importa tanto y cómo tratarlo bien: Las claves que más se filtran no se roban: se suben sin querer. Tres costumbres que evitan casi todos esos sustos, y qué hacer cuando una credencial ya estuvo en un commit.
Cómo manejar ambientes: desarrollo, staging y producción: Para qué sirve cada uno, qué tienen que compartir y qué nunca, cómo tener staging sin pagar un segundo servidor, y el error con los datos que se comete siempre.
Por qué el deploy es la parte más importante de tu proyecto: El código que no está en producción no existe. Por qué un despliegue difícil deforma todo lo demás, qué significa que sea aburrido y cómo se llega ahí.
Qué es Django y por qué sigue siendo una gran decisión: Un framework que trae todo resuelto: ORM, migraciones, panel de administración y seguridad por defecto. Qué gana y qué cuesta elegirlo, y en qué casos conviene otra cosa.
Qué es una SPA y qué gana (y pierde) tu sitio con ella: Una sola página que se reescribe sola: qué problema resuelve, por qué rompió el botón de atrás durante años, qué pasa con el SEO y cuándo conviene no usarla.
Qué significa que algo "se compile en el cliente": La diferencia entre armar el HTML en el servidor y armarlo en el navegador, qué cambia para el usuario, para el buscador y para tu factura de servidor, y por qué hoy casi todo es una mezcla.
Por qué existen el frontend y el backend como cosas separadas: No es una moda ni una forma de dividir tareas: son dos entornos con reglas incompatibles. Qué corre en cada lado, por qué nunca hay que confiar en el navegador y dónde va cada validación.
Qué es una interfaz web y qué hay debajo de lo que ves: Del momento en que escribís una dirección hasta que aparece la página: DNS, TCP, TLS, HTML, CSS y JavaScript, cada uno con su trabajo. Y por qué esa cadena explica casi todos los problemas de rendimiento.
Cómo mantenemos seguros los servidores de ArduMaker, día a día: La parte operativa, no la de diseño: qué se actualiza, qué se vigila, cómo se aíslan las cosas y qué pasa cuando algo se cae a las tres de la mañana.
Por qué se dice que Internet no es seguro: Internet se diseñó para que los paquetes lleguen, no para que nadie los lea. Qué significa eso en la práctica, qué arregló HTTPS, qué sigue siendo visible y por qué el eslabón débil casi nunca es el cifrado.
Una clave SSH por persona: el detalle que cambia todo cuando sos equipo: Por qué compartir una clave privada arruina el modelo entero, cómo se agregan y quitan claves sin tocar a nadie más, y qué hacer el día que alguien pierde la laptop.
Cómo nació SSH: la historia detrás del comando que usás todos los días: Un ataque de captura de contraseñas en Helsinki en 1995, un investigador molesto, y el protocolo que reemplazó a telnet. También por qué OpenSSH existe y qué tiene que ver OpenBSD.
Acceso SSH que se cierra solo: por qué lo hicimos así: El problema no es abrir el acceso, es acordarse de cerrarlo. Cómo funciona un acceso con fecha de vencimiento y qué cambia en la práctica cuando pedir permiso deja de tener consecuencias permanentes.
Qué es SSH y qué pasa exactamente cuando te conectás: El par de claves explicado sin misterio, qué es el desafío que firma tu máquina, por qué el servidor puede tener tu clave pública sin riesgo y qué significa ese aviso gigante de host changed.
Qué es Tailscale y por qué cambió la forma de conectar máquinas: Una VPN sin servidor central por el que pase el tráfico: cómo funciona el modelo de malla sobre WireGuard, qué resuelve que una VPN clásica no, y cuándo no conviene.
Cómo funciona una VPN, de verdad: Qué hace realmente un túnel cifrado, qué esconde y qué no, por qué "VPN = privacidad" es marketing, y para qué sirve de verdad en un equipo técnico.
Un servidor, muchos dominios: cómo se reparte el tráfico: Cómo un solo servidor con una sola dirección atiende diez sitios distintos, qué es SNI, por qué el primer bloque de nginx es especial y cómo evitar que un dominio sirva el sitio de otro.
Qué es nginx y por qué está delante de casi todo: Un proxy inverso explicado sin rodeos: qué resuelve, por qué tu app no debería hablar con Internet directamente, y los tres errores que dan 502, 504 y 413.
IPv4 e IPv6: por qué convivimos con dos Internet a la vez: Se acabaron las direcciones en 2011 y sin embargo todo sigue funcionando. Qué cambió con IPv6, por qué la transición tarda tanto y qué significa para tu servidor.
Cómo funciona realmente una dirección IP: Qué son esos cuatro números, por qué existen las direcciones privadas, qué hace la máscara de red y por qué tu paquete llega a destino sin que nadie conozca el camino completo.
Cómo movemos tráfico entre nuestros servidores sin exponerlo a Internet: Cuando una app en un servidor necesita una base que vive en otro, hay dos caminos: abrir un puerto al mundo o hacer que se vean entre ellos. Por qué elegimos el segundo.
Cuándo conviene una redirección de puertos y cuándo no: Una guía corta para decidir entre abrir un puerto, poner un proxy inverso o levantar un túnel, y la pregunta que resuelve el noventa por ciento de los casos.
Redirección de puertos: qué es y qué resuelve: Qué hace realmente un reenvío de puertos, en qué se diferencia de un proxy inverso y de un túnel SSH, y cuándo cada uno es la herramienta correcta.
Qué es un puerto y por qué tu app necesita uno: Una IP encuentra la máquina; el puerto encuentra el programa. Qué son los 65535 puertos, por qué los de abajo de 1024 son especiales y cómo se diagnostica un "address already in use".
Cómo dar acceso a tu equipo sin repartir contraseñas: Por qué la contraseña compartida siempre termina filtrada, cómo se reparte el acceso por persona y por proyecto, y qué tiene que pasar el día que alguien se va del equipo.
Cómo se crean los usuarios en Linux, por dentro: Qué hace realmente adduser: los cuatro archivos donde vive un usuario, para qué sirve /etc/skel y las dos trampas clásicas al crear y borrar cuentas.
Por qué no usamos root para todo (y qué hacemos en su lugar): Trabajar como root no ahorra tiempo: quita las advertencias, rompe los dueños de los archivos y borra el rastro de quién hizo qué. Qué hace sudo realmente y cómo configurarlo bien.
Por qué Linux es multiusuario desde su primer día: De dónde salen los permisos, los uid y la costumbre de que cada servicio tenga su propio usuario, y por qué ese diseño de hace cincuenta años sigue siendo la mejor defensa gratuita que tenés.
Por qué los servidores no tienen escritorio (y cuándo sí conviene una interfaz): Lo que cuesta una sesión gráfica en un servidor: RAM, superficie de ataque y, sobre todo, trabajo que no se puede repetir. Y los casos donde igual conviene.
Qué es la terminal y por qué sigue siendo la herramienta más rápida: La terminal no es difícil, es escueta. Qué es realmente, en qué se diferencia del shell, cómo leer un comando que nunca viste y las tres salidas de emergencia.
Arquitectura segura por defecto: cómo está pensado ArduMaker: Puertos cerrados por defecto, SSH con fecha de vencimiento, aislamiento por empresa y auditoría de cada comando: por qué la seguridad que depende de la memoria siempre falla.
Consejos para usar un servidor sin romperlo: Cinco costumbres que evitan la mayoría de los incidentes en un servidor: un cambio por vez, copias antes de editar, validar antes de recargar, dejar una sesión de rescate y documentar.
Correo propio que no cae en spam: SPF, DKIM, DMARC y buzones explicados de verdad: Guía honesta sobre SPF, DKIM y DMARC: qué hace cada uno, por qué sin los tres tu correo termina en spam, y cómo montar un dominio de correo con buzones y verificación DNS conversando con una IA. Cubre crear_dominio_correo, verificar_dns_dominio_correo, crear_cuenta_correo, editar_cuota_cuenta_correo y ver_stats_dominio_correo.
Publicar un dominio con HTTPS en tu VPS: nginx, certificados y el 502 de todos los días: Cómo publicar un dominio en un VPS con certificado SSL: qué hace realmente Let's Encrypt, por qué el orden de los pasos importa, cómo leer los logs de nginx para diagnosticar un 502 y cómo hacerlo todo conversando con una IA. Cubre crear_dominio_vps, verificar_dominio_vps, activar_dominio_vps, ver_nginx_dominio_vps, editar_nginx_dominio_vps y ver_logs_nginx_vps.
DNS sin misterio: registros, nameservers y propagación, administrados por conversación: Guía práctica de DNS para desarrolladores: qué hace cada tipo de registro, por qué el TTL importa más de lo que parece, cómo funciona la propagación real y cómo administrar todo conversando con una IA mediante el MCP de ArduMaker. Incluye crear_dominio_empresa, ver_estado_ns_dominio, listar_registros_dns, crear_registro_dns y editar_registro_dns.
Servicios systemd, tareas programadas y logs en un VPS, pedidos en lenguaje natural: Cómo crear servicios systemd, programar tareas recurrentes y leer logs en un VPS pidiéndoselo a una IA. Un ejemplo de uso real para cada herramienta del MCP de ArduMaker: crear_servicio_vps, controlar_servicio_vps, ver_logs_systemd_vps, crear_tarea_vps, ver_logs_tarea_vps y el resto del área de automatización.
Crear y administrar un VPS hablando con una IA: guía práctica del MCP de ArduMaker: Guía práctica para crear, encender, redimensionar y administrar servidores VPS conversando con una IA a través del MCP de ArduMaker. Incluye un ejemplo de uso cotidiano para cada herramienta: crear_vps, controlar_vps, cambiar_plan_vps, ejecutar_comando_vps, ver_estado_vps, crear_usuario_vps, crear_redireccion_vps y más.
Qué es un MCP y cómo funciona el MCP de ArduMaker: Explicación clara del Model Context Protocol (MCP): qué es, cómo funciona y por qué convierte a una IA en un operador real. Incluye un recorrido por el MCP de ArduMaker, sus casi 200 herramientas para VPS, DNS, correo, bases de datos, proyectos y blogs, y un ejemplo real: este mismo artículo fue creado y publicado por una IA usando ese MCP.

Em outros sites

Toda a comunidade