<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Anibal Santiago on Medium]]></title>
        <description><![CDATA[Stories by Anibal Santiago on Medium]]></description>
        <link>https://medium.com/@LecAnibalSM?source=rss-49a22d7e4a55------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*IadUH3mMGhQAyyu249yt7A@2x.jpeg</url>
            <title>Stories by Anibal Santiago on Medium</title>
            <link>https://medium.com/@LecAnibalSM?source=rss-49a22d7e4a55------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:41:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@LecAnibalSM/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Desarrollo con IA — Vibe Coding vs SDD]]></title>
            <link>https://medium.com/@LecAnibalSM/desarrollo-con-ia-vibe-coding-vs-sdd-215d63178d86?source=rss-49a22d7e4a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/215d63178d86</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[spec-driven-development]]></category>
            <dc:creator><![CDATA[Anibal Santiago]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 04:49:20 GMT</pubDate>
            <atom:updated>2026-08-04T04:49:20.143Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jLiaIAoDops3H2zbaYeMrg.png" /><figcaption>VC vs SDD</figcaption></figure><p>Con la llegada de los asistentes de IA, el péndulo ha oscilado hacia la inmediatez y la generación rápida, pero la ingeniería de software robusta sigue requiriendo cimientos sólidos.</p><h3>¿Qué es el “Vibe Coding”?</h3><p>El “Vibe Coding” (Programación por Intuición o por <em>Vibras</em>) es un paradigma emergente popularizado por el uso intensivo de herramientas de Inteligencia Artificial generativa. En lugar de planificar una arquitectura o definir reglas de negocio estrictas, el desarrollador interactúa con la IA utilizando lenguaje natural, descripciones de alto nivel y mucha intuición.</p><p>El ciclo de trabajo se basa en un bucle rápido e informal: escribes un <em>prompt</em> general, la IA genera el código, lo ejecutas, observas si “se siente bien” o si falla, y corriges el rumbo con otro <em>prompt</em>. Es un proceso altamente exploratorio que reduce drásticamente la barrera de entrada a la programación, priorizando la fluidez y la velocidad creativa.</p><h3>¿Qué es SDD (Spec-Driven Development)?</h3><p>El <strong>SDD</strong> como el enfoque sistemático donde las <strong>especificaciones técnicas y de negocio dictan la arquitectura y la generación del código</strong>. Antes de escribir una sola línea (o de enviar un <em>prompt</em> a una IA), el desarrollador o arquitecto define contratos claros, esquemas de datos, diagramas de estado, restricciones y criterios de aceptación.</p><p>En la era del desarrollo asistido por IA, el SDD ha evolucionado para convertirse en la herramienta más poderosa de un ingeniero senior: la especificación se convierte en el contexto definitivo. Al alimentar a la IA con reglas inflexibles y una arquitectura predefinida, el código resultante deja de ser una “adivinanza” iterativa y se vuelve determinista, predecible y listo para producción.</p><h3>Análisis Comparativo</h3><p>Ambos enfoques aprovechan el poder de la inteligencia artificial, pero operan desde filosofías diametralmente opuestas respecto al riesgo y la planificación.</p><h4>Exploración contra Arquitectura</h4><p>El <strong>Vibe Coding</strong> brilla en la fase de ideación y prototipado. Si necesitas una prueba de concepto (PoC) para mañana, programar por intuición te permite saltarte la fricción burocrática y ver resultados funcionales en minutos. Sin embargo, el <strong>SDD</strong> domina indiscutiblemente cuando el sistema debe escalar. La IA, por muy avanzada que sea, tiende a alucinar o a tomar decisiones arquitectónicas de “camino fácil” si no se le imponen límites. El SDD establece esos rieles antes de arrancar el motor.</p><h4>Gestión de la Deuda Técnica</h4><p>En el flujo de Vibe Coding, la deuda técnica se acumula de forma silenciosa. Al ensamblar fragmentos de código sobre la marcha, el resultado suele ser un sistema frágil y altamente acoplado; arreglar un componente a menudo rompe otros tres porque no existe un contrato claro entre ellos. En contraste, el SDD fuerza la creación de módulos cohesivos. Si la especificación es correcta y se entrega a la IA por partes, el código generado es modular, testeable y fácilmente refactorizable.</p><h4>Trabajo en Equipo y Ciclo de Vida</h4><p>Un proyecto construido exclusivamente con Vibe Coding depende en gran medida del contexto mental del creador original. Si otro desarrollador hereda el repositorio, le resultará extremadamente difícil entender <em>por qué</em> la IA estructuró el sistema de esa manera, ya que las decisiones se tomaron en chats efímeros. Con SDD, <strong>la especificación es la fuente de la verdad</strong>. Cualquier miembro del equipo puede leer los documentos de diseño, entender la intención del negocio y regenerar o mejorar el código con total seguridad.</p><p>Para entender mejor cómo estas diferencias impactan el día a día de un desarrollador, interactúa con esta visualización de los flujos de trabajo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*g0aMdG6gCxDyg1Al41EL5A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*WSMNFqpg5UAd7gtdj9nzoQ.png" /></figure><blockquote><strong><em>Nota:</em></strong><em> Observa cómo el bucle del </em>Vibe Coding<em> genera un ciclo de fricción en la etapa de resolución de errores (“Reprompting”), mientras que el flujo del </em>SDD<em> previene la mayoría de los fallos estructurales al trasladar el esfuerzo cognitivo a la fase de diseño inicial.</em></blockquote><h3>Conclusiones</h3><p>Como defensor del Spec-Driven Development, mi conclusión no es que debamos erradicar el Vibe Coding, sino que debemos <strong>confinarlo al entorno correcto del ciclo de vida del software</strong>.</p><ol><li><strong>Usa Vibe Coding para descubrir y desechar:</strong> Es una técnica excepcional para explorar nuevas bibliotecas, construir herramientas internas de un solo uso, participar en <em>hackathons</em>, o generar maquetas de UI rápidamente. Te permite “pensar en voz alta” junto a la máquina. Pero, asume que ese código probablemente deba reescribirse.</li><li><strong>Exige SDD para sistemas de producción:</strong> Cuando estás construyendo el núcleo transaccional de una empresa, una API pública, o un sistema que vivirá más de 6 meses y pasará por las manos de múltiples desarrolladores, no puedes depender de la “intuición” de una sesión de chat. Escribir especificaciones claras y usarlas para parametrizar de forma estricta a la IA es la única forma profesional de garantizar software mantenible, seguro y escalable.</li></ol><p>El futuro de la ingeniería de software asistida por IA no pertenece a quien escribe el <em>prompt</em> más rápido, sino al arquitecto que sabe <strong>especificar con precisión exacta qué es lo que la IA debe construir</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=215d63178d86" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Anatomía de Prompts: Cómo estructurar correctamente un prompt para obtener mejores resultados.]]></title>
            <link>https://medium.com/@LecAnibalSM/anatom%C3%ADa-de-prompts-c%C3%B3mo-estructurar-correctamente-un-prompt-para-obtener-mejores-resultados-e6be44d22c11?source=rss-49a22d7e4a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6be44d22c11</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[prompt]]></category>
            <dc:creator><![CDATA[Anibal Santiago]]></dc:creator>
            <pubDate>Tue, 08 Jul 2025 00:26:11 GMT</pubDate>
            <atom:updated>2025-07-08T00:26:11.069Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_AM_5eDc0y2D7XAUuLGJcw.png" /></figure><p>Redactar un buen prompt no es solo cuestión de hacer una pregunta: es definir con claridad lo que se necesita, desde el contexto hasta el resultado esperado. Para lograr respuestas precisas, útiles y alineadas con tus objetivos, toma en cuenta estos cuatro elementos esenciales:</p><h4>Contexto: punto de partida para entender la situación</h4><p>El contexto es la base de todo. Antes de pedir algo, es importante que el modelo entienda de dónde parte la petición. Describe brevemente la situación en la que te encuentras, tu rol, el conocimiento que ya tienes sobre el tema, y el reto que estás enfrentando.</p><ul><li>¿Quién eres tú y cuál es tu nivel de experiencia en el tema?</li><li>¿Qué sabes hasta ahora? ¿Qué información manejas?</li><li>¿Qué problema estás intentando resolver o qué necesitas lograr?</li></ul><blockquote><em>Ejemplo: “Estoy trabajando en una app web y necesito entender mejor cómo implementar autenticación segura con tokens JWT. Tengo experiencia básica en backend con Node.js, pero no conozco a fondo los temas de seguridad.”</em></blockquote><h4>Rol: define desde qué perspectiva debe responder el modelo</h4><p>Aquí defines el enfoque que quieres que adopte la respuesta. No es lo mismo recibir una explicación desde el punto de vista de un profesor universitario que de un diseñador gráfico. Esto incluye también el tono y nivel técnico del lenguaje.</p><ul><li>¿Qué tipo de perfil o experto debe simular la respuesta?</li><li>¿Debe ser técnica, accesible, amigable, seria, creativa?</li><li>¿A quién va dirigida la respuesta? ¿Quién la va a leer o usar?</li></ul><blockquote><em>Ejemplo: “Explícamelo como si fueras un mentor con experiencia en ciberseguridad, pero que sabe cómo aterrizar conceptos técnicos para alguien que recién empieza en este campo.”</em></blockquote><h4>Tarea específica: indica con precisión qué necesitas que haga</h4><p>Una instrucción vaga genera respuestas vagas. Sé claro y directo con la tarea que quieres que el modelo realice. Si hay condiciones, límites o formatos específicos, menciónalos.</p><ul><li>¿Qué tipo de resultado estás esperando? (una lista, un resumen, un ejemplo práctico, un texto persuasivo, etc.)</li><li>¿Debe incluir o excluir algo? ¿Hay restricciones de formato o longitud?</li><li>¿Hay pasos o estructura que debe seguir?</li></ul><blockquote><em>Ejemplo: “Dame una lista de ventajas y desventajas entre Firebase y Supabase para apps en tiempo real. Solo aspectos técnicos, sin incluir temas de precios ni marketing. Organiza la información en una tabla sencilla.”</em></blockquote><h4>Objetivo: aclara el propósito del resultado</h4><p>El modelo necesita saber no solo qué debe hacer, sino <strong>para qué</strong> lo necesitas. Esto le permite adaptar la respuesta a un propósito real, útil y con sentido práctico.</p><ul><li>¿Qué vas a hacer con la información?</li><li>¿A quién se la vas a presentar o aplicar?</li><li>¿Qué esperas lograr con el resultado?</li></ul><blockquote><em>Ejemplo: “La tabla comparativa que me entregues la voy a usar en una presentación para convencer a mi equipo técnico de elegir la mejor opción para el próximo proyecto.”</em></blockquote><h3>Plantilla para redactar un prompt efectivo</h3><h4>🧱 1. Contexto</h4><p>(Describe la situación de fondo para que el modelo comprenda bien el entorno del problema)</p><blockquote>Soy [tu perfil: profesión, rol o nivel de experiencia] y estoy trabajando en [proyecto, tema o problema].<br> Tengo conocimientos previos sobre [lo que ya sabes o has intentado], pero necesito ayuda con [el reto o duda específica].<br> Esto es parte de [finalidad del proyecto, uso personal, presentación, producto, etc.].</blockquote><h4>🧑‍🏫 2. Rol</h4><p>(Define desde qué punto de vista debe responder el modelo, incluyendo estilo o tono)</p><blockquote>Responde como si fueras [tipo de experto o profesional, con años de experiencia o enfoque deseado].<br> Usa un tono [formal, técnico, directo, accesible, creativo, etc.], pensado para [audiencia o destinatario de la respuesta].</blockquote><h4>🛠️ 3. Tarea específica</h4><p>(Detalla exactamente qué quieres que el modelo haga, con formato, estructura y limitaciones si las hay)</p><blockquote>Necesito que realices [tipo de tarea: análisis, resumen, comparación, explicación, propuesta, etc.].</blockquote><blockquote>Entrega el resultado en formato [lista, tabla, texto corrido, párrafo, pasos, código, etc.].</blockquote><blockquote>Considera lo siguiente:</blockquote><blockquote>Incluir: [puntos clave, requisitos específicos]</blockquote><blockquote>Excluir: [temas o datos que no deben mencionarse]</blockquote><blockquote>Extensión: [cantidad de palabras, párrafos o nivel de profundidad]</blockquote><h4>🎯 4. Objetivo final</h4><p>(Especifica para qué sirve la respuesta y qué esperas lograr con ella)</p><blockquote>Este resultado lo necesito para [toma de decisiones, presentación, desarrollo, evaluación, etc.].<br> Me ayudará a [resolver un problema, elegir entre opciones, explicar un tema, generar ideas, etc.].</blockquote><h4>Ejemplo breve usando la plantilla:</h4><p><strong><em>Contexto:</em></strong><em> Soy desarrollador frontend con conocimientos básicos en Angular. Estoy armando una interfaz de tabla de datos que se conecta con una API REST, pero me cuesta integrar correctamente paginación y ordenamiento.<br></em><strong><em>Rol:</em></strong><em> Responde como si fueras un desarrollador senior especializado en Angular. Usa un tono técnico pero claro.<br></em><strong><em>Tarea:</em></strong><em> Explícame paso a paso cómo implementar una tabla con paginación y ordenamiento en Angular usando Material UI. Incluye ejemplo de código y menciona buenas prácticas.<br></em><strong><em>Objetivo:</em></strong><em> Quiero integrar esto en un proyecto que presentaré en una entrevista técnica.</em></p><h3>Conclusión</h3><p>Un buen prompt no se improvisa: se piensa como si estuvieras explicándole tu necesidad a una persona experta que no conoce tu situación. Cuando incluyes el <strong>contexto, el rol esperado, la tarea específica y el objetivo</strong>, aumentas significativamente la calidad de las respuestas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6be44d22c11" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Anatomía de un archivo Docker Compose: claves para escribir tu YAML correctamente]]></title>
            <link>https://medium.com/@LecAnibalSM/anatom%C3%ADa-de-un-archivo-docker-compose-claves-para-escribir-tu-yaml-correctamente-db0c92000fe8?source=rss-49a22d7e4a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/db0c92000fe8</guid>
            <category><![CDATA[docker-compose]]></category>
            <category><![CDATA[docker-compose-file]]></category>
            <category><![CDATA[dockerfiles]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Anibal Santiago]]></dc:creator>
            <pubDate>Fri, 06 Jun 2025 15:32:10 GMT</pubDate>
            <atom:updated>2026-10-03T05:38:52.836Z</atom:updated>
            <content:encoded><![CDATA[<h3>Docker Compose: claves para escribir tu YAML correctamente</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f3J0sjItsfcfF0qxUxY5Vw.png" /></figure><p>Cuando se trabaja con aplicaciones en contenedores, es común tener que levantar varios servicios que se comunican entre sí. Por ejemplo, una aplicación web puede necesitar un servidor web, una base de datos y un sistema de caché. Manejar cada uno de estos contenedores por separado con docker run puede volverse rápidamente tedioso y propenso a errores. Aquí es donde entra en juego <strong>Docker Compose</strong>.</p><p>Docker Compose permite definir y administrar entornos multi-contenedor de forma declarativa, utilizando un archivo YAML. Esta herramienta no solo reduce la complejidad, sino que también facilita la colaboración y la repetibilidad en distintos entornos.</p><h4>¿Por qué usar Docker Compose?</h4><p><strong>1. Simplificación:</strong><br> En lugar de lanzar manualmente cada contenedor, con Docker Compose puedes definirlos todos en un único archivo docker-compose.yml y levantarlos con un solo comando: docker-compose up.</p><p><strong>2. Orquestación básica:</strong><br> Docker Compose permite definir dependencias y relaciones entre contenedores, lo que resulta útil en entornos donde el orden de arranque es importante (por ejemplo, una app que necesita que la base de datos esté lista antes de iniciar).</p><p><strong>3. Repetibilidad y portabilidad:</strong><br> El archivo docker-compose.yml actúa como una fuente única de verdad. Si alguien más clona tu repositorio, podrá levantar el mismo entorno exactamente como tú lo hiciste, sin ambigüedades.</p><p><strong>4. Red integrada:</strong><br> Docker Compose crea automáticamente una red virtual entre los servicios definidos, permitiendo que se comuniquen fácilmente mediante sus nombres de servicio, sin necesidad de configurar redes manualmente.</p><h4>Cómo se compone un archivo docker-compose.yml y qué debes tener en cuenta</h4><p>Entender cómo está estructurado un archivo docker-compose.yml es clave para sacarle el mayor provecho a Docker Compose. Aunque los archivos pueden llegar a ser bastante extensos en proyectos complejos, los elementos básicos son fáciles de comprender y permiten construir entornos eficientes y organizados desde el principio.</p><p>Estructura básica de un archivo docker-compose.yml</p><pre>version: &quot;3.9&quot;<br>services:<br>  app:<br>    build:<br>      context: .<br>      dockerfile: Dockerfile<br>    ports:<br>      - &quot;3000:3000&quot;<br>    volumes:<br>      - .:/usr/src/app<br>    environment:<br>      - NODE_ENV=development<br>    depends_on:<br>      - db<br><br>  db:<br>    image: postgres:14<br>    environment:<br>      POSTGRES_USER: admin<br>      POSTGRES_PASSWORD: secret<br>      POSTGRES_DB: mydb<br>    volumes:<br>      - db-data:/var/lib/postgresql/data<br><br>volumes:<br>  db-data:</pre><p>Explicación de cada parte:</p><p>version</p><p>Define la versión del esquema de Docker Compose. Actualmente, la más usada es &quot;3.9&quot;, compatible con la mayoría de las características modernas de Docker.</p><p>services</p><p>Contiene todos los contenedores que forman parte de la aplicación. Cada uno se configura individualmente.</p><p>¿Cuándo usar image y cuándo build?</p><p>Ambas opciones son válidas para definir la base del contenedor, pero tienen propósitos distintos:</p><ul><li>image Cuando usas una imagen existente (oficial o personalizada ya construida y publicada en un registry). Ideal para producción. <br>image: node:18</li></ul><pre>services:<br>  app:<br>    image: node:18</pre><ul><li>buildCuando necesitas construir tu propia imagen con un Dockerfile, por ejemplo, para agregar código, dependencias o configuraciones personalizadas. build: . o build: { context: ., dockerfile: Dockerfile.dev }</li></ul><pre>services:<br>  app:<br>    build:<br>      context: .<br>      dockerfile: Dockerfile</pre><p>Uso de variables de entorno con archivo .env</p><p>Docker Compose permite cargar variables desde un archivo .env ubicado en el mismo directorio que el docker-compose.yml. Esto es útil para manejar configuraciones sensibles o que cambian por entorno (desarrollo, producción, etc.).</p><p>Ejemplo de archivo .env:</p><pre>POSTGRES_USER=admin<br>POSTGRES_PASSWORD=supersecreto<br>POSTGRES_DB=mi_basedatos<br>POSTGRES_PORT=5432</pre><p>Archivo docker-compose.yml que usa esas variables:</p><pre>version: &quot;3.9&quot;<br>services:<br>  db:<br>    image: postgres:14<br>    environment:<br>      - POSTGRES_USER=${POSTGRES_USER}<br>      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}<br>      - POSTGRES_DB=${POSTGRES_DB}</pre><p>La instrucción env_file en un archivo docker-compose.yml permite <strong>cargar un conjunto de variables de entorno desde un archivo externo</strong>, generalmente llamado .env u otro nombre personalizado (por ejemplo, .env.db, .env.dev, etc.).</p><p>Es diferente a environment, que define directamente variables dentro del archivo Compose. env_file apunta a un archivo donde están definidas.</p><pre>...<br>services:<br>  db:<br>    image: postgres:14<br>    env_file:<br>      - .env.db<br>    ports:<br>      - &quot;${POSTGRES_PORT}:${POSTGRES_PORT}&quot;<br>    volumes:<br>      - pg-data:/var/lib/postgresql/data<br>...</pre><p>ports</p><p>Mapea los puertos del contenedor a los del host. Por ejemplo, &quot;3000:3000&quot; permite que una aplicación que corre en el contenedor en el puerto 3000 sea accesible desde el navegador a través de <a href="http://localhost:3000.">http://localhost:3000.</a></p><p>depends_on</p><p>Establece dependencias entre servicios. En el ejemplo anterior, el servicio app depende de que db esté disponible, aunque <strong>no garantiza</strong> que db esté listo, solo que el contenedor ya fue creado.</p><p>volumes</p><p>Permite compartir archivos entre el host y el contenedor. Muy útil para desarrollo, ya que los cambios que hagas en tu máquina se reflejan dentro del contenedor en tiempo real.</p><p>volumes (al final del archivo)</p><p>Define volúmenes persistentes que pueden ser usados por uno o más contenedores. Esto es esencial cuando necesitas mantener datos entre reinicios de contenedores, como bases de datos.</p><h4>Buenas prácticas al escribir un docker-compose.yml</h4><ul><li><strong>Nombrar claramente los servicios:</strong> Usa nombres que indiquen su función (por ejemplo, frontend, backend, db), no nombres genéricos como app1, container2, etc.</li><li><strong>Evitar hardcodear secretos:</strong> No pongas contraseñas directamente. Usa variables de entorno o archivos .env.</li><li><strong>Separar configuración para producción y desarrollo:</strong> Puedes tener distintos archivos como docker-compose.dev.yml y docker-compose.prod.yml, o usar extensiones para combinar configuraciones.</li><li><strong>Utilizar volúmenes en bases de datos:</strong> Para evitar perder datos al reiniciar contenedores, asegúrate de que los datos importantes se almacenen en volúmenes nombrados.</li></ul><h4>Conclusión</h4><p>Saber cómo se estructura un archivo docker-compose.yml te da la libertad de diseñar entornos flexibles, portables y fáciles de replicar. Ya sea que estés desplegando una aplicación en la nube, preparando un entorno de desarrollo o simplemente automatizando el arranque de servicios, comprender los bloques principales de Compose te ayudará a mantener tus proyectos organizados y funcionales.</p><p>Un buen archivo docker-compose.yml no solo ejecuta contenedores: documenta el sistema y facilita la colaboración con otros desarrolladores. Vale la pena dedicarle tiempo a entender cómo funciona y cómo aprovecharlo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db0c92000fe8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Un contenedor al vuelo]]></title>
            <link>https://medium.com/@LecAnibalSM/un-contenedor-al-vuelo-30ea8af99022?source=rss-49a22d7e4a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/30ea8af99022</guid>
            <category><![CDATA[docker-run]]></category>
            <category><![CDATA[docker-log]]></category>
            <category><![CDATA[docker-exec]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Anibal Santiago]]></dc:creator>
            <pubDate>Fri, 30 May 2025 15:02:36 GMT</pubDate>
            <atom:updated>2025-05-30T15:02:36.167Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IzWvFwdoZyo6AT9Y1J2qxQ@2x.jpeg" /></figure><p>En este artículo nos centraremos en un aspecto fundamental del flujo de trabajo con Docker: la ejecución de contenedores a partir de imágenes previamente construidas o disponibles en repositorios como Docker Hub. Aprenderemos a iniciar contenedores de forma rápida y eficiente, una habilidad clave para cualquier desarrollador que desee optimizar sus entornos de desarrollo, simplificar el proceso de despliegue y garantizar la consistencia entre distintos entornos.</p><p>Además, exploraremos las herramientas que Docker pone a disposición una vez que el contenedor está en ejecución. Veremos cómo acceder a los registros para monitorear el comportamiento de la aplicación, así como ingresar a una terminal interactiva dentro del contenedor para realizar tareas de depuración o ejecutar comandos directamente en el entorno. Estas funcionalidades resultan esenciales para mantener un control completo sobre nuestras aplicaciones durante su ciclo de vida.</p><h3>Docker run</h3><p>El comando docker run es uno de los más utilizados en el día a día de quienes trabajan con contenedores. Permite iniciar un nuevo contenedor a partir de una imagen, ya sea local o descargada desde un repositorio como Docker Hub. Lo más poderoso de este comando es la flexibilidad que ofrece a través de sus múltiples opciones, que permiten personalizar el entorno de ejecución del contenedor según nuestras necesidades.</p><p>Entre las opciones más comunes se encuentran:</p><ul><li>-e: para definir variables de entorno dentro del contenedor.</li><li>-p: para mapear puertos entre el contenedor y el host.</li><li>-v: para montar volúmenes y persistir datos.</li><li>--name: para asignar un nombre personalizado al contenedor.</li><li>-d: para ejecutar el contenedor en segundo plano (modo <em>detached</em>).</li><li>--rm: para eliminar automáticamente el contenedor cuando se detiene.</li></ul><pre>docker run -d \<br>  --name postgres-dev \<br>  -e POSTGRES_USER=admin \<br>  -e POSTGRES_PASSWORD=admin123 \<br>  -e POSTGRES_DB=mi_basededatos \<br>  -p 5432:5432 \<br>  -v pgdata:/var/lib/postgresql/data \<br>  postgres:16</pre><p>Con esta instrucción estamos:</p><p>•	Asignando el nombre postgres-dev al contenedor.</p><p>•	Definiendo las credenciales de acceso y el nombre de la base de datos mediante variables de entorno.</p><p>•	Exponiendo el puerto 5432 del contenedor al mismo puerto del host, lo que permite conectarnos desde herramientas externas como pgAdmin o DBeaver.</p><p>•	Montando un volumen llamado pgdata para persistir los datos fuera del ciclo de vida del contenedor.</p><p>•	Usando la imagen oficial de PostgreSQL en su versión 16.</p><p>Este enfoque permite levantar entornos completos de forma reproducible y en pocos segundos, ideal tanto para desarrollo local como para pruebas automatizadas.</p><h4>Docker exec</h4><p>Cuando un contenedor ya está en funcionamiento, muchas veces necesitamos ingresar a él para hacer tareas puntuales: revisar archivos, ejecutar comandos, hacer pruebas o simplemente entrar a la terminal para verificar que todo esté funcionando correctamente. Para eso existe docker exec, una herramienta muy útil que permite ejecutar comandos dentro de un contenedor en ejecución, sin detenerlo ni modificar su estado.</p><p>La estructura del comando es sencilla:</p><pre>docker exec [opciones] &lt;nombre_o_id_del_contenedor&gt; &lt;comando&gt; </pre><p>Opciones comunes:</p><ul><li>-it: combina las opciones -i (interactivo) y -t (asigna una pseudo-TTY), lo que permite abrir una terminal con entrada y salida en tiempo real.</li><li>--user: especifica el usuario con el que se debe ejecutar el comando dentro del contenedor.</li><li>--env: permite pasar variables de entorno adicionales al comando que se ejecuta.</li></ul><p>Una de las formas más comunes de usarlo es con las opciones -it, que permiten abrir una terminal interactiva:</p><pre>docker exec -it nombre-del-contenedor bash</pre><p>Esto abre una terminal dentro del contenedor, ideal para explorarlo o ejecutar comandos manualmente. Si el contenedor no tiene bash, se puede usar sh como alternativa.</p><h3>Doker log</h3><p>Cuando un contenedor ya está corriendo, es fundamental poder ver qué está pasando dentro de él. Ya sea para verificar que todo funcione bien, detectar errores o simplemente entender el comportamiento de una aplicación, los logs son una herramienta clave. Docker ofrece el comando docker logs para este propósito.</p><p>Este comando permite visualizar la salida estándar (stdout) y de error (stderr) de un contenedor, es decir, lo que imprimiría normalmente en consola si estuviera ejecutándose de forma local.</p><p>Uso basico :</p><pre>docker logs &lt;nombre_o_id_del_contenedor&gt;</pre><p>Esto muestra todo el historial de salida del contenedor desde que comenzó a ejecutarse. Dependiendo del tipo de servicio que esté corriendo, esto puede incluir mensajes de inicio, errores, consultas a una base de datos, peticiones HTTP, etc.</p><p>Opciones utiles :</p><ul><li>-f: sigue la salida del log en tiempo real, como lo harías con tail -f.</li></ul><pre>docker logs -f mi-contenedor</pre><ul><li>--tail: limita la cantidad de líneas que se muestran desde el final del log.</li></ul><pre>docker logs --tail 100 mi-contenedor</pre><ul><li>--since: muestra los logs desde un momento específico (formato como 2024-05-29T15:00:00 o 10m para los últimos 10 minutos).</li></ul><pre>docker logs --since 10m mi-contenedor</pre><ul><li>--timestamps: agrega marcas de tiempo a cada línea del log, útil para rastrear eventos con precisión.</li></ul><pre>docker logs --timestamps mi-contenedor</pre><p>Estas opciones se pueden combinar. Por ejemplo, si estás depurando algo que ocurrió recientemente, podrías hacer algo como esto:</p><pre>docker logs -f --tail 50 --since 5m mi-contenedor</pre><p>Con ese comando verás las últimas 50 líneas generadas en los últimos 5 minutos, y seguirás recibiendo nueva salida en tiempo real.</p><h3>Conclusiones</h3><p>Trabajar con Docker implica dominar algunas herramientas clave, y entre ellas, docker run, docker exec y docker logs forman una base sólida para cualquier flujo de trabajo serio con contenedores.</p><p>docker run es el punto de partida. Nos permite lanzar contenedores con un alto nivel de personalización, desde el mapeo de puertos y volúmenes hasta la inyección de variables de entorno. Entender cómo se combinan estas opciones es fundamental para construir entornos reproducibles y bien configurados.</p><p>Por otro lado, docker exec nos da la flexibilidad necesaria para intervenir directamente en un contenedor que ya está en marcha. Ya sea para ejecutar una comprobación rápida, depurar un problema puntual o interactuar con un servicio interno, poder &quot;entrar&quot; al contenedor sin tener que reiniciarlo o alterar su estado es una herramienta que ahorra mucho tiempo y dolores de cabeza.</p><p>Y finalmente, docker logs ofrece visibilidad. Es la forma más directa de entender qué está pasando dentro del contenedor cuando algo no sale como se espera. Combinando sus opciones, podemos filtrar, seguir en tiempo real o revisar eventos pasados, lo que resulta clave en entornos de desarrollo y pruebas.</p><p>En conjunto, estos comandos no solo permiten controlar los contenedores de forma precisa, sino que también habilitan una forma más ágil y confiable de desarrollar, probar y mantener aplicaciones. Dominarlos no es opcional: es parte del día a día de cualquier desarrollador que trabaje con contenedores en serio.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=30ea8af99022" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker build: opciones y banderas más comunes con ejemplos]]></title>
            <link>https://medium.com/@LecAnibalSM/docker-build-opciones-y-banderas-m%C3%A1s-comunes-con-ejemplos-eed706200d64?source=rss-49a22d7e4a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/eed706200d64</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[docker-build]]></category>
            <category><![CDATA[docker-build-command]]></category>
            <dc:creator><![CDATA[Anibal Santiago]]></dc:creator>
            <pubDate>Tue, 26 Nov 2024 03:36:50 GMT</pubDate>
            <atom:updated>2024-11-26T03:36:50.540Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CB81kRt_QqV-LXBGNjwaNg.png" /></figure><p>Al comprender la sintaxis y las opciones disponibles del comando <strong>docker build</strong>, puedes personalizar el proceso de construcción para adaptarlo a tus necesidades específicas, como asignar etiquetas, especificar ubicaciones alternas para el Dockerfile, pasar variables en tiempo de construcción o forzar una construcción limpia.</p><p>Al trabajar con el comando <strong>docker build</strong>, existen varias opciones y banderas comunes que ofrecen flexibilidad y personalización. A continuación, exploramos algunas de estas opciones con ejemplos:</p><ul><li>-t o --tag</li></ul><p>Esta opción permite asignar una etiqueta (tag) a la imagen construida, facilitando su referencia y versionado. En este ejemplo, la imagen construida se etiquetará como <strong>sampleapp</strong> con la versión <strong>latest</strong>.</p><pre>docker build -t sampleapp:latest .</pre><ul><li>-f o --file</li></ul><p>Permite especificar un nombre o ubicación alternativos para el Dockerfile si no se llama simplemente <strong>Dockerfile</strong>. En este caso, la imagen se construirá utilizando el Dockerfile llamado <strong>ProductionDockerfile</strong> en el directorio actual.</p><pre>docker build -f ProductionDockerfile .</pre><ul><li>--build-arg</li></ul><p>Con esta opción, puedes pasar variables en tiempo de construcción al Dockerfile, permitiendo una personalización dinámica. Este comando pasa una variable llamada <strong>VERSION</strong> con el valor <strong>10</strong> al Dockerfile.</p><pre>docker build --build-arg VERSION=10 .</pre><ul><li>--no-cache</li></ul><p>Esta opción obliga a Docker a ignorar las capas en caché y realizar una construcción limpia. Este comando fuerza una reconstrucción completa utilizando todas las capas.</p><pre>docker build --no-cache .</pre><ul><li>--target</li></ul><p>Si el Dockerfile tiene múltiples etapas de construcción definidas con la instrucción <strong>FROM</strong>, la opción <strong>--target</strong> permite especificar una etapa específica para construir. En este ejemplo, solo se construirá la etapa definida como <strong>mytarget</strong> en el Dockerfile.</p><pre>docker build --target mytarget .</pre><ul><li>--quiet o -q</li></ul><p>Esta opción suprime la salida del proceso de construcción y solo muestra el ID de la imagen generada. Este comando realiza la construcción de manera silenciosa.</p><pre>docker build --quiet .</pre><p>Con estas opciones, puedes optimizar y controlar el proceso de construcción de tus imágenes Docker según las necesidades de tu proyecto.</p><h3>Ejemplos</h3><h4>* Construcción personalizada con etiqueta, variables de construcción y archivo Dockerfile alternativo</h4><pre>docker build -t myapp:v1.0 --build-arg ENV=production -f Dockerfile.prod .</pre><p><strong>Explicación:</strong></p><ol><li><strong>-t myapp:v1.0</strong>: Asigna la etiqueta <strong>myapp:v1.0</strong> a la imagen construida, facilitando su identificación y versión.</li><li><strong>--build-arg ENV=production</strong>: Pasa un argumento de construcción llamado <strong>ENV</strong> con el valor <strong>production</strong>. Esto puede ser usado en el Dockerfile para configurar variables o definir comportamientos según el entorno.</li><li><strong>-f Dockerfile.prod</strong>: Especifica un archivo Dockerfile alternativo llamado <strong>Dockerfile.prod</strong>, útil para gestionar configuraciones separadas para entornos de desarrollo, pruebas o producción.</li></ol><p>Este comando construye una imagen etiquetada como <strong>myapp:v1.0</strong> utilizando un archivo Dockerfile específico para producción y pasando una variable de entorno.</p><h4>* Construcción limpia y silenciosa apuntando a una etapa específica</h4><pre>docker build --no-cache --target builder -q -t app-builder .</pre><p><strong>Explicación:</strong></p><ol><li><strong>--no-cache</strong>: Obliga a Docker a ignorar las capas en caché y realizar una construcción limpia, asegurándose de que todas las dependencias y configuraciones se obtengan desde cero.</li><li><strong>--target builder</strong>: Indica que solo se debe construir la etapa <strong>builder</strong> definida en el Dockerfile, útil si el Dockerfile tiene múltiples etapas (como una para compilación y otra para el entorno de ejecución).</li><li><strong>-q</strong>: Suprime los mensajes de salida durante la construcción, mostrando únicamente el ID final de la imagen construida.</li><li><strong>-t app-builder</strong>: Asigna la etiqueta <strong>app-builder</strong> a la imagen, identificándola como una construcción específica para la etapa <strong>builder</strong>.</li></ol><p>Este comando genera una imagen de la etapa de construcción, sin usar caché y sin mostrar detalles del proceso de construcción, ideal para scripts de CI/CD que necesitan imágenes consistentes y silenciosas.</p><h4>Conclusiones</h4><p>Con el comando docker build y sus banderas, puedes ajustar todo para que el proceso de construcción sea justo lo que necesitas. Ya sea para un entorno pro o un script de automatización, puedes hacerlo a tu estilo y sin complicarte demasiado. ¡Solo es cuestión de practicar y sacarle jugo! 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eed706200d64" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[¿Tracks  para Docker ?]]></title>
            <link>https://medium.com/@LecAnibalSM/tracks-para-docker-e1ad8a5e3d5a?source=rss-49a22d7e4a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/e1ad8a5e3d5a</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[docker-image]]></category>
            <category><![CDATA[dockerfiles]]></category>
            <dc:creator><![CDATA[Anibal Santiago]]></dc:creator>
            <pubDate>Sat, 16 Nov 2024 06:45:53 GMT</pubDate>
            <atom:updated>2024-11-18T02:42:42.590Z</atom:updated>
            <content:encoded><![CDATA[<h3>La piezas para escribir un Dockerfile</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1XgCKk_0Pdyd5IKootctBg.png" /></figure><p><strong>Construir una imagen en Docker</strong> es un paso esencial para garantizar que una aplicación funcione de forma coherente y predecible en cualquier entorno. Al crear una imagen, se empaqueta todo lo necesario para ejecutar la aplicación, desde el código y las librerías hasta las configuraciones específicas. Este proceso facilita el despliegue de aplicaciones y permite a los desarrolladores trabajar con entornos de manera más eficiente y reproducible.</p><p>Para comenzar a construir una imagen, normalmente se parte de una <strong>imagen base</strong>, que es una plantilla que contiene un sistema operativo ligero o algunos elementos básicos. Docker ofrece varias imágenes base que simplifican este proceso; las imágenes base incluyen configuraciones comunes y sistemas operativos listos para personalizar según las necesidades de la aplicación.</p><p><strong>Imágenes Alpine</strong> son un ejemplo popular de imágenes base. Estas imágenes están diseñadas para ser extremadamente ligeras y seguras, ya que ocupan muy poco espacio y contienen solo los componentes necesarios para ejecutar aplicaciones básicas. Esto hace que las imágenes Alpine sean ideales para proyectos donde la eficiencia y el tamaño reducido son prioritarios.</p><p>Por otro lado, también existe la opción de crear una imagen desde <strong>scratch</strong>, que es una imagen completamente vacía, sin ningún sistema operativo ni herramientas preinstaladas. Crear una imagen desde scratch permite personalizar absolutamente todo lo que se necesita, agregando solo lo que es indispensable. Esto puede ser útil para aplicaciones que requieren un control extremo sobre el entorno y buscan la máxima optimización de recursos.</p><p>Podemos entender mejor el concepto de las imágenes de Docker usando la analogía de <strong>grabar canciones en un CD-R</strong>. Crear una imagen de Docker es como grabar un álbum o una canción en un CD-R para que pueda reproducirse en cualquier reproductor de CD de manera consistente. Al igual que en un CD-R se graban las canciones con todos sus detalles específicos para que puedan reproducirse siempre igual, en una imagen de Docker se incluye el código de la aplicación junto con sus librerías y configuraciones necesarias para que funcione igual en cualquier entorno.</p><p>Así como un CD-R se puede llevar a diferentes lugares y reproducir en varios equipos sin problemas, una imagen de Docker es portátil y se puede ejecutar en cualquier servidor, computadora o en la nube, independientemente de la configuración del sistema operativo. Esto garantiza que, al “reproducir” la aplicación en un entorno nuevo, funcione de la misma manera que en el entorno original.</p><p>Además, como un CD-R que puede duplicarse para compartir la misma música en distintas copias, una imagen de Docker puede almacenarse, compartirse y reutilizarse, ahorrando tiempo y esfuerzo al asegurar que todos los entornos utilicen la misma configuración exacta.</p><p>En Docker, el archivo “<strong>Dockerfile”</strong> es como la lista de instrucciones o “tracks” que se utilizan para grabar las canciones en un CD-R. Este archivo contiene todas las instrucciones paso a paso que definen cómo construir la imagen, especificando qué sistema operativo, librerías, configuraciones y archivos se deben incluir.</p><p>Cada línea del Dockerfile es una “pista” que indica cómo construir y ensamblar la imagen final. Por ejemplo, en el Dockerfile podemos incluir instrucciones para copiar el código de la aplicación, instalar dependencias, configurar variables de entorno, y definir cómo se ejecutará la aplicación.</p><p>De esta forma, el Dockerfile actúa como la guía completa para que Docker pueda construir la imagen de manera consistente y reproducible, igual que un CD-R que se graba siguiendo una lista de canciones e instrucciones específicas para que cada vez que se reproduzca, suene igual.</p><h3>Construyamos un Dockerfile</h3><p>Docker crea imágenes siguiendo los comandos especificados en el Dockerfile. A continuación, exploraremos estos comandos y explicaremos cómo funcionan.</p><p>Formato de Dockerfile:</p><pre># Comentario<br>INSTRUCCIÓN argumentos</pre><p>Los comandos no distinguen entre mayúsculas y minúsculas, Pero como convención escribamoslos en MAYÚSCULAS para que se noten mejor y se distingan de los parámetros.</p><p>Un Dockerfile siempre empieza con el comando FROM, que indica la imagen base desde la cual se construirán todos los comandos que vienen después.</p><h4>FROM</h4><p>FROM [--platform=&lt;platform&gt;] &lt;image&gt; [AS &lt;name&gt;]</p><ul><li>FROM puede aparecer varias veces en el Dockerfile en caso de utilizar etapas de compilación.</li><li>AS name asigna un nombre a la etapa de compilación y puede usarse para el comando FROM más adelante, por ejemplo COPY --from&lt;name&gt;</li><li>--platformEspecifica la plataforma de la imagen, por ejemplo: linux/amd64, linux/arm64 o windows/amd64. El valor predeterminado es la plataforma del dispositivo.</li></ul><h4><strong>WORKDIR</strong></h4><p>El comando WORKDIR en un Dockerfile establece el directorio de trabajo para cualquier instrucción posterior en el archivo, como RUN, CMD, ENTRYPOINT, COPY o ADD. Es decir, cambia el directorio actual dentro de la imagen en el momento de la construcción o al ejecutar el contenedor.</p><pre>WORKDIR /ruta/del/directorio</pre><p>Si el directorio especificado no existe, Docker lo creará automáticamente durante la construcción de la imagen.</p><p>Por defecto, si no se especifica ningún WORKDIR en el Dockerfile, el directorio de trabajo será /, que es la raíz del sistema de archivos en el contenedor. Esto significa que todas las instrucciones que dependan del directorio actual se ejecutarán desde la raíz del contenedor.</p><h4>RUN</h4><p>El comando RUN se utiliza para ejecutar cualquier comando en una nueva capa de la imagen actual y confirmar los resultados.</p><p>El comando RUN tiene 2 formas:</p><ul><li>RUN &lt;command&gt; (shell , el comando se ejecuta en un shell, el valor predeterminado en Linux es /bin/sh -c y cmd /S /C en Windows )</li><li>RUN [&quot;executable&quot;, &quot;param1&quot;, &quot;param2&quot;, ..] (exec)</li></ul><h4><strong>CMD</strong></h4><p>CMD tiene 3 formas :</p><ul><li>CMD [&quot;executable&quot;, &#39;param1&quot;, &quot;param2&quot;, ..] (exec )</li><li>CMD [&quot;param1&quot;, &quot;param2&quot;, ..]( con parámetros predeterminados como ENTRYPOINT)</li><li>CMD command param1 param2 .. (<em>shell</em> )</li></ul><p>El comando CMD en un Dockerfile se usa para especificar el comando predeterminado que se ejecutará cuando un contenedor arranque. Solo debe haber un CMD porque Docker toma este comando como la instrucción final de qué hacer en el contenedor una vez que esté en ejecución.</p><p>Si en el Dockerfile hay más de un comandoCMD, Docker solo usará el último. Los anteriores serán ignorados, ya que Docker sobrescribe el valor de CMD cada vez que aparece uno nuevo. Por eso, es importante definirlo solo al final o asegurarse de que la última instancia sea la que realmente quieres que se ejecute.</p><p>El objetivo principal de CMD es proporcionar programas predeterminados cuando se ejecutan contenedores. Si no, debes especificarlo con ENTRYPOINT .</p><p>Si se utiliza CMD para proporcionar el valor predeterminado para ENTRYPOINT, entonces ambos comandos deben declararse como ARRAY ([&quot;abc&quot;, &quot;xyz&quot;,..])</p><p>A diferencia de la forma <em>shell</em>, la forma <em>exec</em> no llama a un intérprete de comandos (<em>shell</em>), lo que significa que no se ejecutan los procesos normales de un shell. Por ejemplo, al escribir CMD [&quot;echo&quot;, &quot;$HOME&quot;] en forma <em>exec</em>, no se realizará la sustitución de la variable de entorno $HOME, ya que el comando no está pasando por un shell que interprete esa variable.</p><p>Para que se realicen las sustituciones de variables de entorno (o cualquier otra funcionalidad propia de un shell), se puede usar la forma <em>shell</em> o ejecutar el shell de manera directa, como en el siguiente ejemplo: CMD [&quot;sh&quot;, &quot;-c&quot;, &quot;echo $HOME&quot;]. En este caso, se llama explícitamente al shell para interpretar y reemplazar $HOME por el valor correspondiente.</p><p>Al usar la forma <em>exec</em> y ejecutar directamente un shell, será el shell quien se encargue de procesar la sustitución de variables de entorno, no Docker.</p><p>Cuando se utiliza en forma <em>shell</em> o <em>exec</em>, el comando especificado en CMD se ejecuta al iniciar la imagen (es decir, al correr el contenedor).</p><p>Si se utiliza la forma <em>shell</em> de CMD, el comando (&lt;command&gt;) se ejecutará usando /bin/sh -c.</p><pre>FROM ubuntu<br>CMD echo &quot;this is the shell form cmd.&quot; | wc -</pre><p>Si deseas ejecutar &lt;command&gt; sin usar un shell, debes utilizar la forma de arreglo (<em>array form</em>) y especificar la ruta al ejecutable.</p><pre>FROM ubuntu<br>CMD [&quot;/ur/bin/wc&quot;, &quot;--help&quot;]</pre><p>Si deseas que el contenedor ejecute el mismo ejecutable cada vez que se inicie, debes usar el comando ENTRYPOINT (posiblemente en combinación con CMD).</p><p>Si especificas un comando al ejecutar el contenedor con docker run &lt;IMAGE&gt; [COMMAND], este comando sobrescribirá el valor predeterminado definido en CMD.</p><p>No confundas RUN con CMD. El comando RUN ejecuta una instrucción y guarda el resultado en la imagen durante la construcción, mientras que CMD no ejecuta nada durante el <em>build</em>, solo define qué se ejecutará cuando el contenedor arranque.</p><h4><strong>EXPOSE</strong></h4><p>EXPOSE &lt;port&gt; [&lt;port&gt;/&lt;protocol&gt;...]</p><p>EXPOSE La instrucción indica qué puertos escuchará el contenedor cuando esté en ejecución. Puedes especificar el protocolo como TCP o UDP, siendo TCP el predeterminado. Sin embargo, EXPOSE no publica realmente los puertos. Para publicar un puerto, debes usar la opción -p al ejecutar el contenedor con docker run.</p><pre>EXPOSE 80/tcp<br>EXPOSE 80/udp</pre><p>Publicar puertos al ejecutar un contenedor:</p><pre>docker run -p 80:80/tcp -p 80:80/udp</pre><p>Al ejecutar el comando docker run -p 80:80, estás configurando un mapeo de puertos entre el host (tu máquina) y el contenedor. Aquí está cómo se interpreta:</p><ul><li><strong>El primer </strong><strong>80 (antes de los dos puntos </strong><strong>:)</strong>: Este es el puerto externo del <strong>host</strong>. Es el puerto al que las aplicaciones o usuarios externos se conectarán desde fuera del contenedor.</li><li><strong>El segundo </strong><strong>80 (después de los dos puntos </strong><strong>:)</strong>: Este es el puerto interno dentro del contenedor. Es el puerto en el que el servicio o aplicación dentro del contenedor está escuchando.</li></ul><p>En este caso, el puerto 80 del host está redirigido al puerto 80 del contenedor. Cualquier solicitud que llegue al puerto 80 del host será enviada al puerto 80 dentro del contenedor.</p><p>Si estás corriendo un servidor web dentro del contenedor escuchando en el puerto 80, podrás acceder a él desde tu navegador visitando <a href="http://localhost:80.">http://localhost:80.</a></p><h4><strong>ENV</strong></h4><p>ENV &lt;key&gt;=&lt;value&gt; ...</p><p>ENV La instrucción para establecer variables de entorno define valores que estarán disponibles para las instrucciones posteriores en el Dockerfile. Estas variables se mantienen persistentes cuando el contenedor está en ejecución. Puedes ver sus valores usando docker inspect y modificarlos al ejecutar el contenedor con docker run --env &lt;key&gt;=&lt;value&gt; (o su forma abreviada -e).</p><p>Si una variable de entorno solo se necesita durante el proceso de construcción y no para la imagen final, considera establecer su valor directamente en el comando, por ejemplo:</p><pre>RUN DEBIAN_FRONTEND=noninteractive apt-get update &amp;&amp; apt-get install -y ...</pre><p>Otra opción es usar ARG, que no se mantendrá persistente en la imagen final.</p><pre>ARG DEBIAN_FRONTEND=noninteractive<br>RUN apt-get update &amp;&amp; apt-get install -y ...</pre><h4>ADD</h4><p>Existen dos formas para ADD :</p><ul><li>ADD [-chown=&lt;user&gt;:&lt;group&gt;][-checksum=&lt;checksum&gt;] &lt;src&gt;… &lt;dest&gt;</li><li>ADD [-chown=&lt;user&gt;:&lt;group&gt;] [&quot;&lt;src&gt;&quot;,… &quot;&lt;dest&gt;&quot;]</li></ul><p>La segunda forma es necesaria cuando la ruta contiene espacios en blanco.</p><p>La instrucción ADD copia archivos, directorios o URLs remotas desde &lt;src&gt; y los agrega al sistema de archivos de la imagen en la ruta &lt;dest&gt;.</p><p>Se pueden especificar múltiples &lt;src&gt;. Si son archivos o directorios, sus rutas se interpretan como relativas al directorio de construcción (<em>build context</em>).</p><p>&lt;dest&gt; es una ruta absoluta o relativa al WORKDIR, y define dónde se copiará el origen dentro del contenedor.</p><p>Ejemplos:</p><ul><li>Agregar “test.txt” a &lt;WORKDIR&gt;/relativeDir:</li></ul><pre>ADD test.txt relativeDir</pre><ul><li>Usar una ruta absoluta:</li></ul><pre>ADD test.txt /absoluteDir</pre><p>Todos los archivos y directorios creados tendrán un UID y GID de 0, a menos que uses la opción --chown. El usuario y el grupo pueden ser nombres de cadenas o IDs enteros. Los nombres se buscarán en /etc/passwd y /etc/group.</p><h4>Notas:</h4><ol><li>Si realizas la construcción pasando el Dockerfile a través de la entrada estándar (STDIN) (docker build - &lt; somefile), no habrá contexto de construcción. En este caso, el Dockerfile solo puede contener URLs en la instrucción ADD. También puedes pasar un archivo comprimido a través de STDIN (docker build - &lt; archive.tar.gz), en cuyo caso el Dockerfile debe estar en la raíz del archivo y el resto del contenido del archivo se usará como contexto de construcción.</li></ol><h4>Reglas de ADD:</h4><ul><li>La ruta &lt;src&gt; debe estar dentro del contexto de construcción. No puedes usar rutas como ../something /something, ya que el primer paso del comando docker build es enviar el directorio de contexto (y sus subdirectorios) al demonio de Docker.</li><li>Si &lt;src&gt; es una URL y &lt;dest&gt; no termina con /, el archivo descargado desde la URL se copiará a &lt;dest&gt;.</li><li>Si &lt;src&gt; es una URL y &lt;dest&gt; termina con /, el archivo descargado se guardará como &lt;dest&gt;/&lt;nombre_del_archivo&gt;. Por ejemplo:</li></ul><pre>ADD http://example.com/foobar /</pre><ul><li>Esto guardará el archivo en /foobar.</li><li>Si &lt;src&gt; es un directorio, todo su contenido se copiará, incluyendo los metadatos del sistema de archivos.</li><li>Si se usan múltiples &lt;src&gt;, ya sea directamente o con comodines (<em>wildcards</em>), &lt;dest&gt; debe ser un directorio y debe terminar con /.</li><li>Si &lt;dest&gt; no termina con /, se considerará como un archivo regular, y el contenido de &lt;src&gt; se guardará en &lt;dest&gt;.</li><li>Si &lt;dest&gt; no existe, se creará junto con todos los directorios necesarios en su ruta.</li></ul><h4>COPY</h4><p>Tambien contamos con dos formas para COPY :</p><ul><li>COPY [--chown=&lt;user&gt;:&lt;group&gt;] &lt;src&gt;... &lt;dest&gt;</li><li>COPY [--chown=&lt;user&gt;:&lt;group&gt;] [&quot;&lt;src&gt;&quot;,... &quot;&lt;dest&gt;&quot;]</li></ul><p>La segunda forma se utiliza cuando la ruta contiene espacios en blanco.</p><p>En particular, COPY acepta una bandera --from=&lt;name&gt;, que se usa para especificar la ubicación de origen que apunta a una etapa de construcción previa (creada con FROM ... AS &lt;name&gt;).</p><p>COPY funciona de manera similar a ADD, pero con algunas diferencias importantes:</p><ul><li>COPY no realiza extracción automática de archivos comprimidos.</li><li>COPY no puede usarse con URLs remotas.</li></ul><h4><strong>ENTRYPOINT</strong></h4><ul><li>exec (recomendada): ENTRYPOINT [&quot;executable&quot;, &quot;param1&quot;, &quot;param2&quot;]</li><li>shell: ENTRYPOINT command param1 param2</li></ul><p>El comando ENTRYPOINT se utiliza para configurar el ejecutable principal del contenedor.</p><p>Los argumentos de línea de comandos pasados a docker run &lt;image&gt; se agregarán al final de los parámetros definidos en la forma <em>exec</em> de ENTRYPOINT y también sobrescribirán cualquier valor definido en CMD.</p><h4>Limitaciones de la forma shell:</h4><ul><li>La forma <em>shell</em> evita que se utilicen los argumentos de CMD o los argumentos pasados al comando run.</li><li>ENTRYPOINT en forma <em>shell</em> ejecuta el comando como un subcomando de /bin/sh -c, lo que significa que no recibe señales directamente.<br>Esto implica que el proceso ejecutable no será el proceso con PID 1 en el contenedor y no recibirá señales de Unix. Por ejemplo, no recibirá la señal SIGTERM cuando ejecutes docker stop &lt;container&gt;.</li></ul><h4>Notas:</h4><ul><li>Solo el último comando ENTRYPOINT definido en el Dockerfile será efectivo.</li></ul><h3>Conclusiones sobre los comandos en un Dockerfile</h3><p>Después de repasar los comandos que se pueden utilizar en un Dockerfile, es evidente que cada uno cumple un propósito específico en la construcción y configuración de imágenes Docker. Aquí hay algunas conclusiones clave:</p><p><strong>1.- Estructura y Organización:</strong></p><ul><li>Un Dockerfile sigue un flujo lógico que comienza con la elección de la imagen base (FROM) y termina con la definición del comportamiento predeterminado del contenedor (CMD o ENTRYPOINT).</li><li>La correcta organización y uso de los comandos mejora la legibilidad, el mantenimiento y la reutilización del Dockerfile.</li></ul><p><strong>2.- Optimización:</strong></p><ul><li>Usar combinaciones de comandos como RUN para minimizar capas y reducir el tamaño de la imagen es una buena práctica.</li><li>La elección entre COPY y ADD depende de la necesidad específica, ya que ADD tiene funcionalidades adicionales, pero no siempre son necesarias.</li></ul><p><strong>3.- Flexibilidad y Control:</strong></p><ul><li>Comandos como WORKDIR, ENV, y ARG proporcionan herramientas para configurar la imagen y el entorno del contenedor de manera flexible.</li><li>La opción de usar ENTRYPOINT y CMD permite definir comportamientos específicos y predeterminados para el contenedor, con la posibilidad de sobrescribirlos según sea necesario.</li></ul><p><strong>4.- Compatibilidad y Portabilidad:</strong></p><ul><li>Es importante recordar que cada comando tiene sus limitaciones, como el uso de ADD con URLs o las diferencias entre la forma <em>exec</em> y <em>shell</em> de ENTRYPOINT.</li><li>Usar prácticas estándar como escribir comandos en mayúsculas y mantener rutas relativas dentro del contexto de construcción asegura que el Dockerfile sea portátil y fácil de entender.</li></ul><p><strong>5.- Seguridad:</strong></p><ul><li>Es esencial minimizar los permisos, usar --chown al copiar archivos y evitar exponer información confidencial en las variables de entorno.</li></ul><h3>Conclusión Final</h3><p>Un Dockerfile bien diseñado es la base para construir contenedores eficientes, seguros y confiables. Comprender los comandos y sus interacciones permite aprovechar al máximo Docker, asegurando que los contenedores no solo sean funcionales, sino también optimizados para su propósito. Al aplicar estas prácticas, podrás crear imágenes reutilizables y de alta calidad para cualquier tipo de aplicación.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1ad8a5e3d5a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Contexto general sobre Docker]]></title>
            <link>https://medium.com/@LecAnibalSM/contexto-general-sobre-docker-34216d92150b?source=rss-49a22d7e4a55------2</link>
            <guid isPermaLink="false">https://medium.com/p/34216d92150b</guid>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Anibal Santiago]]></dc:creator>
            <pubDate>Thu, 07 Nov 2024 06:46:47 GMT</pubDate>
            <atom:updated>2024-11-07T06:46:47.780Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0_aqxJoZHomgOPfNytONeA.png" /></figure><p><strong>Docker</strong> es una plataforma que facilita el desarrollo, envío y ejecución de aplicaciones de una forma eficiente y sencilla. Con Docker, los desarrolladores pueden empaquetar una aplicación junto con todo lo que necesita para funcionar: desde el código hasta las librerías y dependencias necesarias. Esto permite que las aplicaciones funcionen sin problemas en cualquier entorno, ya sea en la computadora del desarrollador, en servidores de producción o en la nube.</p><p>En resumen, Docker ayuda a que las aplicaciones sean más portátiles, confiables y fáciles de gestionar, sin importar dónde se ejecuten.</p><h3>Docker vs Virtual Machine</h3><p>imagina que quieres tener una “mini versión” de tu computadora dentro de tu computadora para poder probar cosas nuevas sin afectar lo que ya tienes configurado. Aquí es donde entran en juego Docker y las máquinas virtuales (VMs), aunque funcionan de forma diferente:</p><h4>Máquinas virtuales (VMs)</h4><p>Las <strong>máquinas virtuales</strong> son como si instalaras un sistema operativo completo dentro de tu computadora. Cada VM tiene su propio sistema operativo (como Linux o Windows) y se lleva una parte de los recursos (memoria, CPU, etc.) de la computadora principal para funcionar. Esto es genial, porque puedes tener entornos completamente independientes. Sin embargo, como tienen que cargar todo un sistema operativo y sus componentes, las VMs suelen ser pesadas, más lentas de iniciar y consumen bastante espacio y recursos.</p><p><strong>Ejemplo</strong>: Piensa en una VM como si alguien trajera una casa prefabricada y la pusiera dentro de tu casa; necesita su propia estructura, muebles y todo lo que necesita para funcionar como un hogar separado.</p><h4>Docker (Contenedores)</h4><p><strong>Docker</strong>, por otro lado, es mucho más ligero porque no crea un sistema operativo completo por separado. En lugar de eso, usa el sistema operativo de la computadora principal y solo añade lo necesario para que la aplicación funcione, empaquetando únicamente las librerías y herramientas específicas que requiere la aplicación. Esto permite que los contenedores (que son como pequeñas “cajas” con aplicaciones) se inicien rápido, ocupen menos espacio y usen menos recursos.</p><p><strong>Ejemplo</strong>: Docker sería como poner una “habitación funcional” dentro de tu casa, equipada solo con las herramientas necesarias para una tarea específica, sin duplicar todo el resto de la casa. Entonces, si quieres cocinar, solo necesitas una cocina equipada, sin traer otra casa entera.</p><p>En resumen:</p><ul><li><strong>VMs</strong>: Son más pesadas porque crean sistemas completos, como mini-computadoras dentro de tu computadora.</li><li><strong>Docker (contenedores)</strong>: Son ligeros, solo cargan lo necesario para ejecutar la aplicación y aprovechan el sistema operativo principal.</li></ul><p>Esto hace que Docker sea ideal cuando necesitas rapidez, flexibilidad y menos consumo de recursos para ejecutar múltiples aplicaciones en un mismo entorno.</p><h3>¿Cuales son las Piezas con las que trabaja Docker?</h3><p><strong>Docker daemon (dockerd)</strong> es como el cerebro de Docker, un programa que está funcionando en segundo plano para que todo el ecosistema de Docker pueda operar sin problemas. Dockerd se encarga de gestionar las imágenes, contenedores, redes y volúmenes de Docker.</p><p>Además, dockerd puede hablar con otros dockerd en diferentes máquinas, para que puedas controlar los servicios de Docker desde varios lugares. También ofrece una API, que es como un puente de comunicación para que otras aplicaciones puedan conectarse y administrar todo lo que está bajo el control de Docker.</p><p><strong>Objetos de Docker</strong> :</p><ul><li><strong>Images</strong>: Una <strong>imagen</strong> en Docker es como una receta o plantilla que tiene las instrucciones necesarias para crear un contenedor. Normalmente, una imagen se construye a partir de otra imagen y le agrega las personalizaciones que necesites. Por ejemplo, puedes crear una imagen que parta de una base como Ubuntu y luego le añades lo que necesitas, como un servidor Apache y tu aplicación. Así tienes una ‘base personalizada’ lista para usar en tus contenedores.</li><li><strong>Containers</strong>: Un <strong>contenedor</strong> es como una copia en funcionamiento de una imagen. Es decir, cuando tienes una imagen y la pones a trabajar, se convierte en un contenedor. Cada contenedor está aislado del resto, así que no se mezclan ni interfieren entre sí ni con la computadora principal (host). Además, puedes controlar qué tanto acceso tienen a la red y al almacenamiento, manteniendo cada contenedor bien separado de los demás y del sistema principal.</li></ul><blockquote>Cuando se elimina un contenedor, todos los cambios y estados ( por ejemplo, archivo, datos, …) que no se guarden en el almacenamiento persistente desaparecerán.</blockquote><ul><li><strong>Docker client: </strong>docker es una interfaz de línea de comandos (CLI) que se utiliza para interactuar con dockerd a través de comandos (usando API)<br>por ejemplo, Docker Run (crear contenedor). El cliente Docker puede interactuar con múltiples Dockerds (configuración DOCKER_HOST).</li><li><strong>Docker registries</strong> : es donde se almacenan las imágenes de la ventana acoplable. <a href="https://hub.docker.com/">Docker Hub</a> es un registro público, cualquiera puede usarlo.<br>También puedes crear tu propio registro privado. Docker está configurado para buscar imágenes de Docker desde Docker Hub. Puedes extraer imágenes del registro a tu máquina local o enviar tus imagenes al registro.</li></ul><h4>En conclusiones</h4><p>Docker es una herramienta versátil que permite a los desarrolladores empaquetar y ejecutar aplicaciones de manera eficiente, asegurando portabilidad y consistencia en cualquier entorno. A diferencia de las máquinas virtuales, que requieren un sistema operativo completo y mayores recursos, Docker utiliza contenedores ligeros que comparten el sistema operativo principal, lo que reduce el consumo de recursos y acelera los tiempos de inicio. Docker funciona mediante varios componentes como el Docker daemon, que gestiona las imágenes y contenedores, y el cliente de Docker, que facilita la interacción a través de comandos. Además, Docker Hub permite almacenar y compartir imágenes de forma pública o privada. Esta arquitectura hace que Docker sea una excelente opción para quienes buscan flexibilidad, rapidez y escalabilidad en el desarrollo y despliegue de aplicaciones.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34216d92150b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>