La semana pasada se liberó DeepSeek como Open Source, un modelo de lenguaje bastante eficiente que pone en riesgo a empresas como OpenAI y otros. Este model llego a cambiar las reglas del juego ya que ahora cualquiera puede tener el modelo corriendo en sus propios servidores, hacer fine-tunning y utilizarlo desde sus propias aplicaciones. En este tutorial te voy a mostrar como instalar DeepSeek en Amazon AWS paso a paso y como usar el API rest.

Asigna un nombre a tu instancia, yo usé 

Deep Learning Base OSS Nvidia Driver GPU AMI

, esta configuración incluye los drivers de Nvidia instalados y listos para usar.

Selecciona el tipo de instancia, estoy usando 

 si prefieres algo más económico, aunque será un poco más lento.

 existente para iniciar sesión por SSH. Si no tienes llaves, deberás crear una, simplemente sigue las instrucciones al hacer clic en el botón de crear.

En la sección de red, recomiendo permitir tráfico solo desde

, de esta forma solo tú podrás acceder a la instancia. Si tu IP cambia, puedes actualizarla fácilmente en AWS.

Para el almacenamiento, elegí 100 GB, lo cual debería ser suficiente. Sin embargo, si necesitas más espacio, puedes aumentar el tamaño del disco más adelante.

Cuando todo esté listo, haz clic en el botón amarillo 

 a la derecha para iniciar tu nueva instancia.

Una vez que tu instancia este corriendo necesitas conectarte vía SSH, abre una terminal y conéctate de la siguiente manera:

$ ssh  -i ~/.ssh/[YOUR-AWS-KEYS].cer ubuntu@[YOUR-INSTANCE-IP]

Asegúrate de usar el certificado adecuado así como la IP de la instancia que acabas de crear.

Para ejecutar modelos LLM, necesitamos un cliente u orquestador que cargue el modelo y permita interactuar con él. Hay varias opciones disponibles, pero una de las más populares es 

Luego, instalemos Ollama con este comando:

$ curl -fsSL https://ollama.com/install.sh | sh

Ahora que tenemos Ollama instalado, podemos cargar DeepSeek y ejecutarlo. Es muy sencillo, solo ejecuta el siguiente comando:

, pero puedes reemplazarla con la que necesites. Este comando descargará el modelo, que pesa aproximadamente 9 GB, así que ten paciencia.

Después de un tiempo, el modelo estará listo para usarse. Mi primera prueba será el famoso ejercicio de encontrar las “R” en una palabra. Todos los modelos fallan en esta prueba, veamos cómo lo hace DeepSeek.

Y falló... aunque en algún momento estuvo cerca, el resultado final perdió una "R". Es fascinante cómo muestra el proceso de razonamiento, es realmente impresionante.

En este punto, tenemos el modelo funcionando en la terminal, pero sería genial poder llamarlo mediante una API REST. ¡Afortunadamente, Ollama permite hacerlo!

Actualmente, el modelo está ejecutándose y Ollama crea un servidor HTTP local con una API REST que podemos usar, pero necesitamos configurar NGinx para habilitar el acceso mediante un proxy inverso.

Instalar NGinx es muy sencillo, solo ejecuta el comando anterior. Ahora, asegurémonos de permitir tráfico HTTP en el firewall:

Después, configuraremos el proxy inverso actualizando la configuración predeterminada de NGinx:

$ sudo vim /etc/nginx/sites-available/default

 que intenta servir archivos estáticos y copia-pega lo siguiente dentro del bloque 


# Configuración original (comentar o eliminar para usar la nueva)
#location / {
#   try_files $uri $uri/ =404;
#}

location / {
    proxy_pass http://localhost:11434;
    proxy_set_header Host localhost:11434;

    # Manejar solicitudes preflight de CORS
    if ($request_method = OPTIONS) {
        add_header Access-Control-Allow-Origin *;
        add_header Access-Control-Allow-Methods *;
        add_header Access-Control-Allow-Headers "Content-Type, Authorization";
        add_header Access-Control-Max-Age 3600;
        return 200;
    }

    # Configurar encabezados CORS para otras respuestas
    add_header Access-Control-Allow-Origin *;
    add_header Access-Control-Allow-Methods *;
    add_header Access-Control-Allow-Headers "Content-Type, Authorization";

    proxy_set_header Origin "";
    proxy_set_header Referer "";
}



Por último, abre el puerto HTTP para tu IP (o cualquier servidor autorizado). Ve a la consola de AWS, haz clic en los detalles de la instancia (en mi caso 

, agrega una nueva regla, establece el puerto en 

Abre tu navegador y ve a la dirección IP de tu instancia. Deberías ver un mensaje indicando que Ollama está ejecutándose.

Puedes llamar a la API desde tu computadora local. Por ejemplo, abre la terminal y ejecuta este comando:

curl http://[TU-IP-DE-INSTANCIA]/api/generate -m 600 -d '{
  "model": "deepseek-r1:14b",
  "prompt": "Why is the sky blue?"
}'



La primera vez tomará un tiempo ya que necesita cargar el modelo. El parámetro 

 establece un tiempo de espera de 10 minutos, y 

¡Y eso es todo! Ahora puedes llamar al API REST desde tu instancia en AWS. Desde aquí, puedes comenzar a desarrollar aplicaciones y software que usen este modelo LLM.

Instalando DeepSeek en AWS EC2 paso a paso para principiantes

La IA generativa requiere muchos recursos y un equipo potente. Necesitas comprar tarjetas Nvidia para poder ejecutar con éxito Stable Diffusion u otro modelo. Si eres como yo, puedes buscar soluciones accesibles como AWS. En este tutorial, te voy a mostrar cómo instalar ComfyUI + Flux para generar imágenes increíbles en Ubuntu.

Lo primero que necesitas hacer es iniciar sesión en la consola de Amazon AWS. En la barra de búsqueda superior, escribe 

 y selecciona la primera opción en los resultados. Verás algo como esto:

A continuación, debes hacer clic en el botón naranja 

 para configurar el hardware que necesitamos para ejecutar Flux y generar imágenes.

Completa el formulario con los siguientes valores:

: Selecciona una clave existente o crea una nueva, asegúrate de guardar la nueva clave en un lugar seguro, ya que la usaremos más tarde para conectarnos a la instancia.

Todos los demás valores pueden configurarse con los valores predeterminados. Una vez que termines, haz clic en el botón amarillento 

Después de recibir un mensaje de éxito, vuelve a la lista de instancias, haz clic en la nueva instancia y verás la 

 en la columna central. Copia esta IP ya que la utilizaremos para conectarnos vía SSH.

Abre tu terminal favorita o un cliente SSH y conéctate a la instancia que acabamos de crear. Podemos hacerlo ejecutando el siguiente comando.

$ ssh -i ~/.ssh/[YOUR-KEY-FILE-NAME].cer ubuntu@[YOUR-API_ADDRESS]

Asegúrate de establecer el certificado correcto, de lo contrario, no te autenticarás correctamente. Después de iniciar sesión, deberíamos actualizar nuestro sistema ejecutando los siguientes comandos:

A continuación, necesitamos instalar el controlador NVidia para poder usar las GPUs. He probado otras AMIs que incluían los drivers y todo estaba instalado, pero hubo varios errores al instalar los modelos. Me di cuenta que es más fácil instalar manualmente los controladores y todo lo que necesitamos; toma un poco más de tiempo, pero menos errores. Simplemente ejecuta el siguiente comando:

Luego necesitamos Python, primero debemos agregar el repositorio donde se encuentra la distribución oficial y luego instalar el paquete usando apt:

$ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt install python3.10

Es importante establecer el Python predeterminado al ejecutar comandos 

 en la terminal, así que vamos a crear el alias a continuación:

$ sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.10 2

Para verificar si todo está instalado, podemos imprimir la versión de Python:

AUTOMATIC1111 requiere ejecutar entornos virtuales, por lo tanto, necesitamos instalar 

¡Hemos terminado con las dependecias! Todo lo que necesitamos hacer es reiniciar la instancia y deberíamos poder usar las GPUs NVidia para ejecutar los modelos. Abre la consola de AWS, selecciona la instancia y haz clic en la opción 

Vuelve a iniciar sesión en tu instancia y clona el repositorio de stable diffusion web ui.

$ git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui

 para habilitar la conexión a A1111 desde cualquier computadora, usar el flash attention más rápido cuando utilices modelos y permitir que instalar extensiones cuando te conectes de forma remota.

$ cd stable-diffusion-webui
$ vim webui-user.sh

En este archivo, necesitamos encontrar la línea donde se define 

, descomentar la línea y establecer el siguiente valor.

export COMMANDLINE_ARGS="--listen --opt-sdp-attention --enable-insecure-extension-access"

El último paso es instalar y ejecutar A1111, lo hacemos ejecutando el siguiente comando:

, ahora necesitamos abrir ese puerto en nuestra instancia para poder abrirlo en nuestro navegador.

Ve a la consola de AWS y haz clic en la instancia, luego en la pestaña 

. Esto evitará que otras personas usen tus modelos. Si tu IP cambia, tendrás que volver aquí y nuevamente agregar tu nueva IP.

Después de guardar, deberías poder abrir A1111 en tu navegador favorito. Simplemente escribe la IP de tu instancia seguida del puerto, por ejemplo: 

Si todo salió bien, deberías poder ver la consola de A1111. ¡Adelante y pruébalo! Deberías ver algo como esto:

Como puedes ver, las imágenes generadas no se ven muy bien. ¡Necesitamos instalar Flux! Pero antes de eso, vamos a instalar ConfyUI, una herramienta con una mejor interfaz que crea flujos para generar imágenes.

Vuelve a la carpeta de inicio y clona el proyecto ComfyUI desde GitHub.

$ cd ~
$ git clone https://github.com/comfyanonymous/ComfyUI

Ahora vamos a compartir modelos con A1111 duplicando el archivo 

 y estableciendo la ruta a los modelos en A1111. Esto lo hacemos para no descargar los modelos dos veces, es mejor tenerlos compartidos y así ahorramos espacio en el disco duro.

$ cd ComfyUI
$ cp extra_model_paths.yaml.example extra_model_paths.yaml
$ vim extra_model_paths.yaml

Dentro de este archivo, necesitamos localizar la línea donde se define el 

base_path: /home/ubuntu/stable-diffusion-webui

Finalmente, ejecuta ComfyUI con este comando:

Instalar ComfyUI para generar imágenes con Flux

Hace un par de semanas actualicé el diseño de este sitio, decidí usar Next.JS para generar todos los archivos HTML y CSS de manera estática, para luego ponerlos en GitHub pages. Todo mi contenido ahora está en Notion y soy muy feliz escribiendo.

En este tutorial te voy a mostrar como automatizar el deployment, la idea es usar GH Actions para hacer el build y correr los scripts que sacan la información de Notion. Tuve algunos problemas que me gustaría documentar por si le sirven a alguien más.

Lo primero es crear un archivo para el nuevo workflow en tu repositorio, este archivo lo vas a crear dentro del directorio  

, si este directorio no existe lo puedes crear. Puedes nombrar el archivo como 

Dentro de este archivo vas a definir tres secciones, el nombre (

) del workflow, el evento que lo inicializa (

Aquí está la configuración que yo he usado para mi proyecto. Es importante mencionar que los pasos van a variar dependiendo de cada proyecto.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install

La configuración anterior define un job llamado 

 que se ejecuta en una máquina Ubuntu con la última versión disponible.

Los pasos definidos son secuenciales y lo primero que hace es descargar el código de GitHub haciendo un checkout con git. Luego instala Node.js con la versión indicada, en este caso la versión 14. Por último instala las dependencias del proyecto.

Como ya mencioné antes, toda mi información de este blog está en Notion, por lo tanto cree dos scripts que se conectan al API Rest de Notion y descargan todos los posts publicados, también van descargando las imágenes asociadas a cada post y generando thumbnails para los posts.

Antes de generar el sitio estático con Next.js, necesito descargar la información y guardarla en archivos JSON que voy a usar en el build, para eso simplemente agrego los dos scripts al job que se definió en el paso anterior.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install
      - name: Download posts
        run: npm run blog
      - name: Download projects
        run: npm run projects

He definido estos scripts dentro del archivo 

 en mi proyecto, por lo tanto puedo usar 

Una vez que ya tengo toda la información en archivos JSON y las imágenes descargadas a la máquina Ubuntu donde estoy haciendo el build, ya puedo pasar al siguiente paso que es generar todos los archivos  HTML y CSS.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install
      - name: Download posts
        run: npm run blog
      - name: Download projects
        run: npm run projects
      - name: Build
        run: npm run build
      - name: Export
        run: npm run export

Next.JS provee dos comandos para generar sitios estáticos, 

. Así que simplemente agrego estos dos pasos al job y listo.

El último paso es deployar el build a GitHub pages, lo único que tenemos que hacer es agregar este paso a la lista de jobs.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14.x'
      - name: Install dependencies
        run: npm install
      - name: Download posts
        run: npm run blog
      - name: Download projects
        run: npm run projects
      - name: Build
        run: npm run build
      - name: Export
        run: npm run export
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./out

nos permite acceder al build, generar un nuevo commit y hacer un push al 

 branch, esto hará que el sitio sea actualizado.

Para poder hacer push, es necesario que le demos el token de github, esta es la llave del repositorio y se puede acceder mediante la variable de entorno 

Otra cosa a considerar en esta configuración es el 

, aquí tenemos que indicarle el directorio dónde está el build, en este caso Next.js pone todos los archivos generados dentro del folder 

Dentro del código fuente, accedo a algunas variables de entorno, ahí tengo el Secret Key para el API de Notion, el número de posts por página y otras cosas más.

Las llaves de Notion no las quiero agregar al repositorio, por lo tanto debo usar variables de ambiente. GitHub te provee una manera de definir environments, cada uno puede tener diferentes valores, por ejemplo, podrías tener uno para 

. En mi caso no requiero tener varios ambientes, así que solo voy a definir uno que se llama 

 de tu repositorio, podrás manejar estos ambientes. Una vez que crees tu ambiente, asegúrate de darle acceso al branch 

 para que se puedan usar estos valores en el build.

Aquí puedes definir todos tus llaves secretas en la sección 

, con esto estamos listos para usar estas llaves en nuestro workflow.

Una vez que has definido tus valores secretos, queda solamente agregarlos a la configuración, aquí vamos a usar la propiedad 

 para indicarle el nombre del ambiente que acabamos de crear con nuestros valores secretos.

Con esto el script podrá acceder a estas variables de entorno, pero estas variables realmente las necesitamos en el código fuente, por lo tanto debemos agregarlas al ambiente del build. Para esto usamos la propiedad 

, aquí podemos acceder a los valores secretos y también definir valores de configuración para nuestros proyecto, por ejemplo aquí puse el número de posts por página, información que no es secreta.

El script final quedaría de la siguiente manera.

name: Deploy to GitHub Pages
on:
  push:
    branches:
      - main
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: github-pages
    env:
      NOTION_PK: ${{ secrets.NOTION_PK }}
      NOTION_DB_ID: ${{ secrets.NOTION_DB_ID }}
      NEXT_PUBLIC_GA_MEASUREMENT_ID: "UA-12345-1"
      POST_PER_PAGE: "6"
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '16.x'
      - name: Install dependencies
        run: npm install
      - name: Blog Data
        run: npm run blog
      - name: Projects Data
        run: npm run projects
      - name: Build
        run: npm run build
      - name: Export
        run: npm run export
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./out

¡Eso es todo! Cada vez que hagas un push al repositorio o merge a un PR al branch main, la acción se ejecutará de manera automática, haciendo que tu flujo de trabajo sea mucho más efectivo y automatizado.

, te recomiendo el curso de mi amigo Armando, es un curso bastante completo donde vas a aprender cosas como integrar Stripe para recibir pagos, autenticación y manejo de sesiones, acceso a base de datos y muchas cosas más, en verdad que te lo recomiendo mucho.

Puedes usar mi cupón para tener un 20% de descuento en la compra del curso: 

también puedes dar click en el siguiente link: 

Como automatizar el deployment de Next.JS en Github Pages 

Primero que nada es necesario tener tus dos ambientes configurados correctamente, en la documentación puedes ver una guia paso a paso de como hacerlo: 

https://devcenter.heroku.com/articles/multiple-environments

Una vez que tienes tus dos ambientes corriendo satisfactoriamente necesitas instalar el plugin pgbackups en ambos ambientes.

$ heroku addons:add pgbackups --remote staging
$ heroku addons:add pgbackups --remote production


Una vez que tienes el plugin en ambos ambientes necesitas hacer un backup de producción para luego llevarlo a tu ambiente de pruebas:

$ heroku pgbackups:capture --remote production


Una vez que tienes listo tu backup ejecutas el siguiente comando:

$ heroku pgbackups:restore DATABASE_URL `heroku pgbackups:url --remote production` --remote staging


Al ejecutarlo te saldrá un mensaje de alerta donde te dirá que tu ambiente de pruebas va a ser sobre-escrito, te pide confirmar escribiendo el nombre de tu aplicación de pruebas. Una vez que confirmar se realiza la restauración.

Es importante mencionar que se perderá toda la información de tu base de datos de pruebas porque será sobre-escrita por la base de datos de producción.

El Blog

Últimas publicaciones

Instalando DeepSeek en AWS EC2 paso a paso para principiantes

Instalar ComfyUI para generar imágenes con Flux

Como automatizar el deployment de Next.JS en Github Pages

Como crear un backup de producción a staging en Heroku

Conecta conmigo!

Tags

Te ayudo a mejorar al entrevistar, únete a mi lista de correo.

También estoy en Youtube