Ejercicio 2: Chat con IA Local usando Docker y Ollama 🤖

Este ejercicio demuestra cómo crear y orquestar un sistema de dos contenedores Docker para desplegar una aplicación de chat que interactúa con un modelo de lenguaje grande (LLM) local. La arquitectura se compone de:

• Un contenedor con **Ollama** sirviendo el modelo **Deepseek-Coder**.
• Un contenedor con un servidor web **Apache** que aloja la interfaz de chat (HTML, CSS, JS).
• Una red de Docker para permitir la comunicación entre ambos contenedores.

Paso 1: Preparación del Entorno (Ollama y el Modelo)

El primer paso es levantar el servicio de Ollama en un contenedor y descargar el modelo que utilizaremos. Esto aísla el entorno de IA y facilita su gestión.

1.1. Correr el contenedor de Ollama

Este comando descarga la imagen oficial de Ollama y la ejecuta, exponiendo el puerto 11434 para que nuestra aplicación pueda comunicarse con la API.

docker run -d -p 11434:11434 --name ollama ollama/ollama

1.2. Descargar el modelo Deepseek-Coder

Una vez que el contenedor `ollama` está en ejecución, usamos `docker exec` para ejecutar un comando dentro de él. En este caso, le pedimos a Ollama que descargue (`pull`) el modelo `deepseek-coder`.

docker exec -it ollama ollama pull deepseek-coder

Paso 2: Creación de la Interfaz Web

La interfaz es una aplicación web simple que consta de tres archivos principales: `index.html` (estructura), `style.css` (diseño) y `app.js` (lógica).

El archivo clave es app.js, que se encarga de enviar las solicitudes del usuario a la API de Ollama y mostrar la respuesta en el chat. La conexión se define con la siguiente URL, apuntando al nombre del contenedor de Ollama, que actuará como un hostname dentro de la red de Docker.

// Dentro de app.js
const OLLAMA_API_URL = 'http://ollama:11434/api/generate';

Paso 3: Containerizar la Aplicación Web

Para empaquetar nuestra aplicación web, utilizamos un `Dockerfile` que define una imagen basada en el servidor web Apache (`httpd`).

3.1. Dockerfile

Este archivo de configuración le indica a Docker que use la imagen de Apache como base y copie nuestros archivos (`index.html`, `style.css`, `app.js`) al directorio donde Apache sirve el contenido web.

# Usa la imagen oficial de Apache httpd
FROM httpd:latest

# Copia los archivos de tu página web al directorio por defecto de Apache
COPY ./index.html /usr/local/apache2/htdocs/
COPY ./style.css /usr/local/apache2/htdocs/
COPY ./app.js /usr/local/apache2/htdocs/

3.2. Construir la imagen

Con el `Dockerfile` en nuestro directorio, ejecutamos el comando `docker build` para crear la imagen, a la que llamamos `mi-apache-chat`.

docker build -t mi-apache-chat .

Captura del proceso de `docker build` en la terminal de VS Code.

Paso 4: Red y Despliegue de Contenedores

Para que el contenedor de Apache pueda comunicarse con el de Ollama, ambos deben estar en la misma red de Docker. Si no lo hacemos, el `fetch` en JavaScript a `http://ollama:11434` fallaría.

4.1. Crear una red de Docker

Creamos una nueva red tipo "bridge" llamada `mi-red`.

docker network create mi-red

4.2. Conectar los contenedores a la red

Conectamos tanto el contenedor `ollama` (ya en ejecución) como el futuro contenedor de Apache a esta red.

docker network connect mi-red ollama
# (El contenedor de apache se conectará al crearlo)

Ejecución de los comandos `docker network` en la terminal.

4.3. Correr el contenedor de la aplicación web

Finalmente, ejecutamos el contenedor de nuestra aplicación web, conectándolo a `mi-red`, exponiendo el puerto 8080 y nombrándolo `mi-apache-chat`.

docker run -d -p 8080:80 --name mi-apache-chat --network mi-red mi-apache-chat

Paso 5: Resultado Final

Al acceder a `http://localhost:8080` en el navegador, la interfaz de chat se carga y es completamente funcional. Las solicitudes del usuario viajan desde el frontend en el contenedor de Apache hasta el backend de IA en el contenedor de Ollama a través de la red interna de Docker.

La aplicación final interactuando con el modelo Deepseek-Coder.