DevOps: La nube y la automatización pagan algunos de los sueldos remotos más altos que hay. Aprendelas y elegí vos dónde vivís y cuánto cobrás.

Description

KUBERNETES: Volvete el ingeniero que revisa los manifiestos, rollouts y clusters que te escribe un agente de IA y al que le confían producción porque caza lo que se le escapó al modelo

Este libro te entrena para ser el revisor del Kubernetes vibe-codeado, no para memorizar comandos de kubectl. Arranca desde una premisa distinta a la de cualquier otro libro de orquestación: el agente escribe los manifiestos, y tu ventaja es entender qué hace de verdad esa config para poder revisarla con un criterio que la herramienta no tiene. Asume un manejo práctico de contenedores (la guía de Docker está ahí si querés esa profundidad) y dedica un capítulo ajustado al modelo de contenedor que necesitás, después va a fondo donde de verdad vive la revisión de Kubernetes: qué hacen el control plane y su reconciliation loop, el ciclo de vida del Pod y por qué Running no es Ready, cómo los Deployments y los rollouts deciden si un release corta conexiones, cómo un Service encuentra un Pod, cómo la config y los secrets llegan a un contenedor sin filtrarse, cómo el almacenamiento persistente y los StatefulSets mantienen vivos los datos a través de la reprogramación, cómo los probes y los resource requests y el scheduler deciden si tu sistema sobrevive a la carga, cómo reacciona el autoescalado, cómo los namespaces y RBAC contienen una brecha, cómo observás y depurás un cluster que no podés ver, y cómo Helm lo empaqueta entre entornos. Aprendés todo eso como lo necesita un revisor: leyendo los manifiestos reales que un agente generaría y decidiendo qué está bien, qué es plausible-pero-peligroso, y qué hay que rebotar. La progresión va de un solo Pod, a un Deployment corriendo detrás de un Service, a todo un sistema en un cluster y dónde se rompe bajo tráfico real. Casi no hay práctica de comandos acá, y mucho sobre reconciliación, integridad de datos, secrets, redes, seguridad, y las formas específicas en que los manifiestos de un agente salen mal. Para ingenieros que van a vibe-codear sus clusters igual y quieren ser los que cazan lo que el modelo se perdió.

AWS: Pasá del ingeniero que despliega nubes al que las aprueba, el que ascienden y pagan más por ver lo que un agente de IA deja pasar

Este libro te entrena para ser el revisor de AWS vibe-codeado, no para memorizar la consola. Arranca desde una premisa distinta a la de cualquier otro libro de AWS: el agente escribe la infraestructura, y tu palanca es entender los servicios lo suficiente como para juzgar la arquitectura, el costo y el blast radius con las tres preguntas que el agente nunca hace. Vas a aprender qué son en realidad los servicios centrales y cuándo cada uno es la herramienta correcta, EC2 y Lambda y las opciones de contenedores para cómputo, S3 y RDS y DynamoDB y ElastiCache y Redshift para almacenamiento y datos, Athena y OpenSearch para analítica y búsqueda, SQS y SNS y SES para desacoplar y mandar correo, y Bedrock para IA, y vas a aprender las bases que deciden si algo de eso es seguro y barato, el least privilege de IAM, la VPC y dónde va cada capa, cómo se arma un endpoint HTTPS de verdad con Route 53 y un certificado y un balanceador, y cómo leer una factura antes de que llegue. Cada capítulo diseña una pieza real de un sistema que funciona, da una estimación de costo ilustrativa y muestra la arquitectura buena-contra-mala que un agente produciría, construyendo desde un solo servicio hasta un diseño completo expresado como infraestructura como código revisable con el CDK. Acá casi no hay clicks en la consola y sí mucho sobre costo, seguridad, datos y las formas específicas en que el cloud de un agente sale mal. Para ingenieros que van a vibe-codear en AWS de todas formas y quieren ser los que cazan el diseño que los iba a filtrar, romper o fundir.

GCP: Leé la nube que armó un agente de IA y volvete el ingeniero al que pagan más y le confían producción, no el que sube una sorpresa de cinco cifras.

Este libro te entrena para ser el revisor de Google Cloud vibe-codeado, no para memorizar la consola. Arranca desde una premisa distinta a la de cualquier otro libro de nube: el agente escribe la infraestructura, y tu palanca es entender qué hace en realidad la plataforma para poder revisarlo con el criterio que la nube no tiene. Vas a aprender qué evalúa en realidad IAM y por qué el mínimo privilegio es todo el juego, qué significan de verdad el plan y el state de Terraform y por qué revisar el plan no es negociable, cómo Cloud Run escala, hace cold start y factura, qué te obliga a manejar la entrega at-least-once de Pub/Sub, cómo elegir entre Cloud SQL, Firestore y un cache Redis según el patrón de acceso, por qué BigQuery factura por byte escaneado, y qué son en realidad los embeddings, un índice vectorial y la memoria de un agente, y vas a aprender todo eso como lo necesita un revisor: leyendo el Terraform, la política de IAM y la config de servicios reales que generaría un agente, con una aplicación de ejemplo diseñada a lo largo de los capítulos y un modelo de costos para cada servicio, decidiendo qué está bien, qué es plausible pero peligroso y qué hay que devolver. La progresión va de revisar un solo recurso y sus permisos, a revisar un servicio y sus capas de datos y de IA, a revisar toda la arquitectura por seguridad, costo y falla bajo carga. Acá casi no hay click por click y sí mucho sobre identidad, redes, costo y las formas específicas en que la nube de un agente sale mal. Para ingenieros que van a vibe-codear en Google Cloud de todas formas y quieren ser los que cazan lo que se le escapó al modelo.

PYTHON: Volvete la habilidad que las empresas siguen pagando cuando la IA escribe el código, el que caza los bugs que corren pero están mal antes de que lleguen a producción

Este libro te entrena para ser el revisor de Python vibe-codeado, no para memorizar el lenguaje. Arranca desde una premisa distinta a la de cualquier otro libro de Python: el agente escribe el código, y tu palanca es entender qué hace ese código en realidad para poder revisarlo con el criterio que el intérprete no tiene. Vas a aprender a qué se liga en realidad un nombre y por qué el aliasing y la mutabilidad causan los bugs que causan, qué verifica y qué no verifica un type hint, qué está haciendo en realidad el event loop detrás de async y await, por qué el global interpreter lock hace que tus threads no sean el paralelismo que creés, qué hacen realmente un ORM y un pool de conexiones, y cómo las piezas se integran en un servicio que corre, y vas a aprender todo eso como lo necesita un revisor: leyendo código real que el agente generaría y decidiendo qué está bien, qué es plausible pero peligroso y qué hay que devolver. La progresión va de revisar un solo objeto y un solo nombre, a revisar un componente como la capa de datos o el pipeline de requests, a revisar cómo encaja todo el sistema y dónde se va a romper bajo carga real. Acá casi no hay ejercicios de sintaxis y sí mucho sobre el modelo de objetos, concurrencia, fallas y las formas específicas en que el Python de un agente sale mal. Para ingenieros que van a vibe-codear en Python de todas formas y quieren ser los que cazan lo que se le escapó al modelo.

AGENTES EN PRODUCCIÓN: Volvete el ingeniero de IA por el que las empresas pelean, el que convierte una demo que impresiona en el producto del que un negocio depende todos los días.

Esta guía te muestra cómo llevar agentes de IA de un prototipo que anda en tu máquina a un sistema en producción que sirve tráfico real, rápido y sin que los costos se disparen. Armar el agente es la parte fácil; ponerlo a servir a miles de usuarios con baja latencia, alta confiabilidad y costos controlados es otro juego, y es justo donde la mayoría de los proyectos se traba. La estrategia del libro no es darte recetas sueltas, sino el orden en que hay que tomar cada decisión del salto a producción: cómo estructurar el sistema para que aguante carga real, cómo orquestar las llamadas a herramientas sin que se vuelvan un caos, cómo ver qué pasa por dentro antes de que falle, cómo frenar los costos antes de que exploten, y cómo blindarlo con guardrails, CI/CD y escalado en la nube. Cada capítulo ataca el punto exacto donde un agente prometedor se cae en producción, y te deja la decisión tomada en vez del problema abierto. Para ingenieros que ya construyeron agentes de IA y ahora necesitan entregarlos en producción de forma confiable y sostenible.

CI/CD: Armá pipelines de CI/CD con GitHub Actions, arrancando por linters y tests y terminando en despliegues blue-green y canary

Ya escribís el código. Lo que todavía no tenés es una forma de deployarlo que no te cueste un fin de semana. Este libro te lleva de un deploy manual y con los dientes apretados a un pipeline que lleva un cambio de tu editor a producción mientras vos mirás tranquilo, porque cada paso es automático, chequeado y reversible. Arrancás con una app chica y con bugs y un deploy a mano que da miedo, y agregás una capa a la vez, recién después de haber sentido el problema que resuelve: los linters y hooks que atrapan un error antes de que salga de tu máquina, los tests unitarios, de integración y end-to-end que frenan un mal merge, la branch protection que mantiene main siempre listo para salir, los pasos de build y contenedores que empaquetan la app igual todas las veces, los chequeos de seguridad que corren temprano en lugar de después de un incidente, la infraestructura como código que levanta staging y producción cuando hace falta, y los despliegues blue-green, canary y con feature flags que te dejan lanzar sin caídas y volver atrás apenas algo huele mal. No te da un YAML terminado para pegar. Te enseña a leer un build roto, rastrear una falla hasta el commit que la causó, y decidir qué chequeo va dónde, para que el pipeline sea tuyo y no una caja negra que tenés miedo de tocar. Para el ingeniero que ya lo sabe escribir y está harto de ser el que deploya a mano y reza.

DOCKER: Dejá de copiar Dockerfiles que no entendés y entregá contenedores que sí, chicos, rápidos y seguros, de tu máquina a producción.

Esta guía te muestra cómo usar Docker a propósito, para que el contenedor que entregás sea chico, rápido, reproducible y seguro en lugar de un Dockerfile que copiaste y cruzaste los dedos. Arranca desde qué es de verdad una imagen, capas apiladas en un filesystem, y construye el modelo mental que vuelve obvio todo lo demás: cómo funciona el build y por qué el cache de capas hace o rompe tu tiempo de build, cómo escribir un Dockerfile que se mantiene chico con builds multi-stage y una imagen base ajustada, qué es de verdad un contenedor cuando corre como proceso bajo namespaces y cgroups, cómo el networking y los volúmenes conectan servicios y persisten datos, qué arma Docker Compose para el desarrollo local y la carrera de readiness que esconde, y cómo endurecer una imagen y empujarla a un registry para que los mismos bytes corran en producción. El libro no te tira una referencia de flags. Te enseña a leer un Dockerfile y un compose y a juzgarlos, a achicar una imagen inflada, a mantener un secreto fuera de una capa, y a saber exactamente qué corre cuando arranca tu contenedor. Para ingenieros que van a containerizar su app igual y quieren ser dueños de lo que entregan.

TERRAFORM: La habilidad de infraestructura que te consigue el sueldo de senior y la confianza para tocar producción

Este libro te enseña a manejar infraestructura real como código con Terraform, de forma segura, en equipo, sin aprender las partes difíciles destruyendo producción. Arranca desde la idea central que la mayoría de los tutoriales pasa por arriba: el archivo de estado es la memoria de Terraform de lo que construyó, casi todo lo confuso que hace Terraform viene del estado, y entenderlo es lo que separa a alguien que puede correr apply de alguien en quien se puede confiar para hacerlo. Construye desde tu primer recurso hasta el flujo que te mantiene seguro (escribir, plan, leer el plan con cuidado, apply), y te enseña a leer un plan buscando la línea que dice destroy antes de que sea tarde. Después cubre lo que el uso real necesita: variables y outputs, estructurar módulos reutilizables en vez de copiar y pegar, manejar varios entornos sin duplicar todo, y manejar secretos para que nunca caigan en el repo ni en el estado. Los capítulos de colaboración son donde los equipos de verdad se lastiman: estado remoto y locking para que dos applies no se corrompan, qué hacer cuando el estado se desincroniza de la realidad, importar infraestructura existente, y correr Terraform en CI para que los cambios se revisen como código. Cierra con la disciplina del cambio seguro, el destroy que nunca tenés que correr por accidente, el radio de impacto de un módulo, y tratar los cambios de infraestructura con el mismo cuidado que una migración de base de datos. Los ejemplos son infraestructura real, mostrada construida mal y después bien. Para ingenieros que quieren infraestructura que puedan reproducir, revisar y confiar.

ANSIBLE: Volvete el ingeniero cuya habilidad de infra se paga como senior, y dejá de ser el único del que depende todo el fleet

Este libro te enseña a automatizar infraestructura de verdad con Ansible, de forma segura, a lo largo de un fleet, sin aprender las partes dolorosas en producción. Arranca desde la idea que la mayoría de los tutoriales se saltea: Ansible funciona porque declarás el estado que querés, no los comandos para llegar, y todo el beneficio, correr la misma automatización cien veces y obtener el mismo resultado, vive en una palabra, idempotencia. Construye desde tu primer inventory y playbook hasta la disciplina que te mantiene a salvo: escribir tareas seguras de correr de nuevo, leer un run en check mode para ver el diff antes de aplicarlo, y estructurar variables, templates y roles para que tu automatización se reúse en vez de copiarse en cada proyecto. Después cubre lo que el uso real exige: mantener los secretos fuera del repo con Vault, reaccionar al cambio con handlers y condicionales, y probar que un rol anda con Molecule antes de que toque un host real. Los capítulos de fleet son donde los equipos se lastiman de verdad: correr sobre cientos de hosts sin martillarlos a todos de una, hacer rolling updates para que un cambio malo se frene en el primer lote en vez de en todo el fleet, delegar tareas, y correr Ansible en CI para que los cambios de infraestructura se revisen como código. Cierra con la disciplina de un cambio seguro, el radio de explosión de un play, y tratar un run que toca todo el fleet con el mismo cuidado que una migración de base de datos. Los ejemplos son automatización real, mostrada escrita mal y después bien. Para ingenieros que quieren una infraestructura que puedan reproducir, revisar y correr sin cruzar los dedos.

OBSERVABILITY: Aprendé a ver qué hace tu software en producción y a decir qué está roto a las 3am cuando los demás no pueden, la habilidad de confiabilidad que se paga como senior y te vuelve difícil de reemplazar

Este libro te entrena para ver qué hace tu software en producción, y para quedarte con esa visibilidad como un revisor se queda con un diff. Arranca desde donde de verdad está la mayoría de los ingenieros: el código sube, quizás lo escribió un agente, corre, y nadie chequeó si lo podías ver correr. Así que el libro enseña los tres pilares desde cero, usando un servicio que instrumentás de punta a punta en cada capítulo, una API de notas llamada Quill con un endpoint de resumen que llama a un modelo, para que las lecciones se acumulen en vez de resetearse. Aprendés logging estructurado que una persona puede buscar bajo presión, con niveles que significan algo y un correlation id que te deja seguir un request a través del ruido. Aprendés las métricas que de verdad cazan caídas, RED y USE, counters y gauges e histogramas, y por qué un gráfico de latencia p99 te dice lo que un promedio esconde. Aprendés tracing distribuido, siguiendo un solo request a través de servicios para encontrar dónde viven el tiempo y la falla. Aprendés a armar dashboards que se ponen en rojo cuando los usuarios sufren en vez de quedarse en verde durante una caída, y alertas que le avisan a una persona por un síntoma roto en lugar de un disco lleno, sin quemar a la rotación de guardia con ruido. Aprendés error tracking que agrupa y contextualiza fallas reales en vez de ahogarte en duplicados, visibilidad de guardia e incidentes, cuándo agarrar un log contra una métrica contra un trace, y qué cuesta la observabilidad para que la factura y la cardinalidad no te sorprendan. El hilo conductor es la pregunta de un revisor hecha de día, con calma, en un cronograma: si producción se rompiera ahora mismo, ¿podrías decir qué está mal, y qué tan rápido? Para ingenieros que van a subir servicios igual y quieren ser los que los pueden ver cuando importa.

CLAUDE: Dejá de usar Claude Code como un chat que de paso escribe código. Manejalo como el ingeniero agéntico que es, en la terminal, tu editor, el escritorio y el CI, y va a entregarte un día de laburo en una hora sin dejarte un despelote atrás

Esta guía enseña la habilidad duradera detrás de Claude Code: no una lista de features que para el trimestre que viene ya cambiaron, sino cómo manejar una herramienta agéntica de programación para que haga trabajo real en el que podés confiar. Arranca donde está el dolor (el día que te salvó y el día que te quemó) y después recorre los siete movimientos que separan al que opera del que la herramienta pasa por arriba. Vas a configurarla en todos los entornos y saber cuándo ir a la terminal, cuándo a tu editor, cuándo al escritorio y cuándo al navegador. Vas a darle el contexto una vez (un archivo de memoria del proyecto, el repo, un plan acordado antes de que toque el código) para que deje de repreguntar y de adivinar. Vas a manejar una sola tarea como corresponde, leyendo el diff y guiando, para que un buen cambio nunca se vuelva un desparramo malo. Vas a poner los permisos para que vuele en lo seguro y frene en lo peligroso, y decidir qué autoaprobar y qué frenar. Vas a correr trabajo en paralelo (subagentes, varias sesiones, worktrees aislados) sin que las piezas choquen. Vas a extenderla con los conectores, los hooks y los comandos que la hacen encajar en tu stack. Y vas a meterla en el CI para que revise, arregle y responda issues sola mientras no la mirás. Cierra con en quién te convertís cuando todo esto es automático: el ingeniero que entrega más, confía en lo que sale y vale más porque la máquina le multiplica el criterio en vez del despelote. Para el ingeniero que quiere que Claude Code se sienta una palanca, no una tragamonedas.

COMUNICAR: El update que nadie te tiene que ir a pedir. Avisás que estás trabado antes de que cueste una semana, das una fecha que después sostenés, sacás la mala noticia mientras todavía es chica y contás tu trabajo para que lo vea la gente que decide los aumentos

Este libro trata sobre la habilidad que decide si tu buen trabajo se llega a ver alguna vez: contarle a la gente que te rodea en qué anda la cosa, seguido y con honestidad, antes de que te lo tengan que ir a pedir. Arranca desde una verdad incómoda. Dos ingenieros hacen un trabajo igual de bueno; al que lo comunica claro lo confían, lo ascienden y le pagan más, y al callado lo dejan pasar, y esto no es injusto: es una señal que el callado nunca mandó. De ahí en adelante despliega un pequeño sistema operativo de comunicación honesta que vas a poder correr el resto de tu carrera. Vas a aprender a armar el estado que nadie te tiene que perseguir, con un ritmo que hace que tu manager deje de preguntarse dónde estás. Vas a aprender a avisar que estás trabado en el momento en que te trabás, en vez de esconderlo hasta que es una crisis, y por qué el que pide ayuda temprano se ve más fuerte, no más débil. Vas a aprender a dar una fecha en la que de verdad creés y a corregirla en el instante en que se corre, así tu palabra sigue valiendo algo. Vas a aprender a sacar la mala noticia mientras todavía es chica, con la forma que hace que confíen más en vos por haberla dicho. Vas a aprender a escribir como lee un ejecutivo apurado, así lo único que importa entra en la primera línea y el pedido es imposible de pasar por alto. Y vas a aprender a hacer visible tu trabajo sin fanfarronear, contando la historia de qué cambió gracias a él, y a estar en desacuerdo de un modo que te hace respetar y quedar registrado en vez de resentido. Cada regla es un hábito, planteado para que sepas exactamente cómo se ve cuando lo estás haciendo bien. Cierra con el ingeniero en que te convertís cuando nada de esto te cuesta esfuerzo: ese al que la conducción le confía lo importante, porque siempre sabe en qué estado está. Para el ingeniero cansado de ver a peores comunicadores adelantarse, y listo para volverse ese que nadie tiene que perseguir.

CONFIABILIDAD: Construí sistemas que no te despiertan a las 3 de la mañana y volvete el ingeniero al que le confían producción, la habilidad de confiabilidad que paga como un senior y te devuelve las noches

Este libro convierte el apagar incendios en ingeniería de confiabilidad: mantener los sistemas arriba a propósito para que producción deje de manejarte la vida. Sigue un solo servicio, Atlas, una plataforma de pagos que vive prendida fuego, y lo vuelve calmo, enseñando las movidas que separan a un equipo que duerme de uno que no. Vas a aprender a decidir qué tan confiable es suficiente con SLOs y presupuestos de error para que no toda alerta sea una crisis, a automatizar el trabajo repetitivo que se come tu guardia, a ver qué está haciendo producción de verdad en vez de adivinar, y a manejar un incidente con un runbook y la cabeza fría a las 3 de la mañana. Se apoya en el canon del rubro, el Site Reliability Engineering de Google, el Accelerate de Forsgren, Humble y Kim, y The Phoenix Project de Gene Kim, y lo convierte en práctica: postmortems sin culpa que arreglan el sistema en vez de la persona, las cuatro métricas DORA que prueban que estás mejorando, deploys que no necesitan un rezo, quedar arriba cuando el tráfico se duplica, y la lección de flujo que explica por qué el trabajo se sigue acumulando. Para el ingeniero cansado de que lo llamen por lo mismo de siempre, que quiere que producción aguante, y dormir.