# Controlar varias impresoras usando instancias Docker

## Qué necesitamos?

A continuación os detallamos los componentes que vamos a necesitar, indicar que vamos a centrar esta guía basada en Raspberry Pi pero podemos usar cualquier otro "host" que soporte Docker.

* Raspberry Pi 3B+ o superior, idealmente una 4 con 2Gb al menos de RAM
* Tarjeta Micro SD y un lector de estas si nuestro ordenador no tiene lector integrado, con un mínimo de 8Gb aunque lo aconsejable son 16Gb o más dado que vamos a tener varias instancias... es aconsejable que esta SD sea de la máxima calidad y velocidad posibles
* Una imagen de Raspberry PiOS (idealmente la lite). Descargaremos e instalaremos el [**Raspberry Pi Imager**](https://raspberrypi.org/software) en nuestro ordenador que nos facilitará la tarea de generar la SD para nuestra Raspberry.
* Un cliente SSH para conectar por terminal a nuestra Pi, aconsejamos [**Terminus**](https://termius.com/) ya que es multiplataforma y dispone de versión para teléfono/tablet... además de que tiene un interfaz sencilla y funcional.
* Un scanner de red para nuestro teléfono/tablet para poder detectar si nuestra Pi se enlazó correctamente en nuesta red. En este caso aconsejamos [Fing](https://www.fing.com/products/fing-app).
* Un editor de textos como [**Visual Studio Code**](https://code.visualstudio.com/download), [**Notepad++**](https://notepad-plus-plus.org/download/) o [**Atom**](https://atom.io/). Es importante usar uno de estos ya que algunos como Word, Wordpad o editores con formato enriquecido pueden añadir caracteres de escape en los ficheros de configuración y no funcionar correctamente.
* Obviamente un par de impresoras 3D al menos y un par de webcams si queremos controlar visualmente estas

## Instalación de PiOS usando Raspberry Pi Imager

Podemos usar la herramienta **Raspberry Pi Imager** para personalizar, crear y quemar la imagen de PiOS que es quizás la forma más sencilla.

* Descargaremos e instalaremos el [Raspberry Pi Imager](https://raspberrypi.org/software) en nuestro ordenador
* Buscaremos la imagen de PiOS en **Choose OS** y dentro de **Raspberry Pi OS (other)** y seleccionaremos **Raspberry Pi OS Lite** (32 o 64 bits dependiendo del modelo que Raspberry que tengamos)
* Abriremos **Advanced Options** (icono de engranaje) para configurar las opciones de nuestra Wifi si es necesario para ello dentro de las opciones para seleccionar el OS pulsaremos **CTRL+SHIFT+X (Windows) o CMD+SHIFT+X (MAC)**. En la nueva ventana aparecerán nuevas opciones avanzadas, la parte importante es la de configuración de nuestra wifi donde seleccionaremos nuestro **SSID**, **contraseña** y **país.**\
  También es aconsejable:
  * **Habilitar SSH** usando autentificación por password
  * Configurar **Time Zone** y nuestro **layout del teclado**

![](/files/-MeUxT07Fx5ApyGkjeWP)

* Elegiremos la SD y grabaremos la imagen.
* Extraeremos de forma segura la SD y la colocaremos en nuestra Raspberry, al encenderla y pasados unos segundos ya podremos conectarnos a ella tal como indicamos en los siguientes puntos de la guia.
* Si hemos hecho todos los pasos de forma correcta y configurado nuestra Wifi o conectado por cable nuestra Raspberry ya podremos mirando en nuestro router o mediante [Fing](https://www.fing.com/products/fing-app) encontrar la IP de nuestra Raspberry.

## Haciendo login usando Terminus via SSH

Si hemos realizado el proceso anterior tenemos nuestra Pi lista para conectarnos, para ello usaremos [**Terminus**](https://termius.com/) que es un cliente SSH multiplataforma y bastante intuitivo. Básicamente añadiremos un nuevo host, le daremos un nombre, IP, puerto (22) y el usuario y password por defecto (pi/raspberry).

![](/files/BKj2ede3uFlXlBfGkaER)

{% hint style="danger" %}
Por seguridad es muy aconsejable que cambiemos el password por defecto de nuestra Pi. Para ello usaremos el comando **passwd**

![](/files/IPnwoHmBHXX8tcDodMuV)\
Una vez cambiado reiniciaremos usando el comando **sudo reboot**
{% endhint %}

## Actualización del sistema e instalación de Docker

Una vez ya tenemos acceso SSH otro de los pasos es asegurarnos que nuestro PiOS está actualizado, usaremos el siguiente comando:

```bash
sudo apt-get update && sudo apt-get upgrade -y
```

Una vez finalizado el proceso procederemos a instalar Docker:

```bash
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
```

Daremos permisos a nuestro usuario pi a Docker y reiniciamos:

```bash
sudo usermod -aG docker pi
reboot
```

![](/files/jWCb4MOvJ88J6oxMVlPv)

## Instalación de Portainer

En un mundo ideal lo aconsejable es que conozcamos los comandos Docker para gestionar nuestras instancias... la realidad es que es mucho más sencillo y visual usar una interfaz/UI web para gestionarlas de una forma sencilla. En nuestro caso siempre usamos [**Portainer**](https://www.portainer.io/).

Para instalar Portainer lanzaremos desde el terminal los siguientes comandos:

```bash
docker pull portainer/portainer-ce:linux-arm
docker run -d -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:linux-arm
```

Donde el primer comando **docker pull** descargará la imagen del container Portainer a nuestra Pi y el segundo, **docker run**, lo ejecutará.

![](/files/SgvqxlBtKximTggyRBmN)

Si todo ha ido bien ya tendremos nuestro container con Portainer funcionando y solamente deberemos acceder a el desde nuestro browser usando <http://RaspberrypiIP:9000> donde RaspberrypiIP es la IP que encontramos en nuestro router o mediante Fing y usamos para conectar por SSH.

![](/files/flCeRo5iHxXXw1id1hlO)

El primer paso del asistente de Portainer es para ajustar el password del usuario admin, no te aconsejo por ahora cambiar el nombre del usuario, solamente seguiremos las indicaciones y daremos sobre **Create user**.

El siguiente paso es el seleccionar el tipo de entorno de containers a gestionar. En nuestro caso seleccionaremos **Docker** y daremos sobre **Connect**.

![](/files/GkCl1fIgHQHY48et02IP)

De nuevo si todo ha salido según lo esperado ya tenemo nuestro Portainer gestionando nuestro entorno Docker funcionando!!!

![](/files/wMRmr8MXUWcp4KPGUur6)

## Identificando nuestras impresoras y cámaras USB

Ya estamos cerca de poder tener nuestra multi instancia de Octoprint listo, el siguiente paso es identificar nuestras impresoras y cámaras para preparar nuestros contenedores.

Asumiendo que tengamos nuestras impresoras y webcams conectadas a nuestra Pi lanzaremos el siguiente comando:

```bash
ls /dev | grep 'ttyUSB\|ttyACM'
```

Este comando debería de mostrarnos los puntos de montaje de nuestras impresoras:

![](/files/vyBbt90HGcA1ln2h8O1z)

Ya tenemos nuestro par de impresoras detectadas y nos anotaremos sus nombres añadiendo /dev/ a lo detectatado en el punto anterior:

```
/dev/ttyACM0 --> Impresora #1
/dev/ttyUSB0 --> Impresora #2
```

Ahora haremos algo similar pero para detectar nuestras cámaras:

```bash
v4l2-ctl --list-devices
```

![](/files/zY6EVmzKVrpxnB0fW2Fb)

De los dispositivos detectados solamentete usaremos los dos últimos que son nuestras cámaras. La información importante es:

```
/dev/video0 --> WebCam #1
/dev/video2 --> WebCam #2
```

Ya tenemos todo detectado!!! ahora volveremos a nuestro Portainer.

## Creando multiples instancias de Octoprint con Docker-Compose

De vuelta a nuestro Portainer iremos en STACKS y ADD STACK:

![](/files/amQyNOTr1sf2zLzUWJm6)

Esto abrirá el interfaz de Docker-Compose donde nos pedirá el nombre del stack el cual es aconsejable usar un nombre fácil de identificar si tenemos pensado usar otros containers en el futuro... en nuestro caso usaremos multiinstance.

En la parte de **web editor section**, vamos a escribir el **Compose** que podéis encontrar más abajo.

![](/files/e9GBB63qnM5G7CWLVYP8)

{% hint style="warning" %}
**Por favor asegúrate que pones correctamente los parámetros de impresora y cámara detectados en el punto anterior.**
{% endhint %}

```yaml
version: '2'
volumes:
  octoprint-1:
  octoprint-2:
services:
  ghost5:
    image: octoprint/octoprint
    ports:
    #Puerto para instancia octoprint controlara Impresora #1
      - 5001:80
    devices:
    #Impresora #1
      - /dev/ttyUSB0:/dev/ttyUSB0
    #WebCam #1
      - /dev/video0:/dev/video0
    volumes:
      - octoprint-1:/home/octoprint/.octoprint
    environment:
      #Calidad del streaming de WEBCAM #1
      - MJPG_STREAMER_INPUT=-n -r 1280x720 -f 30
      #Habilitar streaming WEBCAM #1
      - ENABLE_MJPG_STREAMER=true
    restart: always
  prusa:
    image: octoprint/octoprint
    ports:
    #Puerto para instancia octoprint controlara Impresora #2
      - 5002:80
    devices:
    #Impresora #2
      - /dev/ttyACM0:/dev/ttyACM0
    #WebCam #2
      - /dev/video2:/dev/video0
    volumes:
      - octoprint-2:/home/octoprint/.octoprint
    environment:
      #Calidad del streaming de WEBCAM #2
      - MJPG_STREAMER_INPUT=-n -r 1280x720 -f 30
      #Habilitar streaming WEBCAM #2
      - ENABLE_MJPG_STREAMER=true
    restart: always
```

Una vez completado el Compose daremos en **Deploy the stack**.

Mágicamente si todo ha ido bien las dos instancias Octoprint estarán listas... para verificarlo iremos a **Containers**.

En la siguiente captura podemos ver los containers levantados con el estatus **RUNNING** y el puerto usado por cada uno de ellos:

![](/files/H3pgR9imGDgeWvcOwOzc)

Ahora ya podemos comenzar a configurar nuestros nuevos Octorpint siguiendo nuestra [**guía**](/octoprint/instalacion/configurando-octoprint.md)**.**

\*\*Para acceder a cada instancia pondremos en nuestro navegador la http\://\*\*RaspberrypiIP:5001 para acceder a nuestra instancia de la impresora 1 y \*\*http\://\*\*RaspberrypiIP:5002 para acceder a la instancia de la impresora 2.

Esperamos que os fuera de ayuda!!!


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://marlin.3dwork.io/octoprint/controlar-varias-impresoras-usando-instancias-docker.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.