# Programación remota con Raspberry Pi

Las minicomputadoras de la serie Raspberry Pi, en sus diferentes modelos, permiten acceder a una computadora de bajo costo. Además, a través de los pines GPIO, es posible interactuar con dispositivos de hardware similares a un microcontrolador.

Siendo Raspberry Pi una computadora, podemos utilizarlo como un servidor y acceder de forma remota a través del protocolo SSH. También podemos programarlo usando Visual Studio Code.

En este post, explicaré cómo configurar un PC con Ubuntu y VSCode, conectado a través de una red Wi-Fi, para autenticarnos en un Raspberry Pi y programarlo de forma remota utilizando el protocolo SSH.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675642216796/30421ee0-31a0-4bed-b313-4c010f227d41.png align="center")

# ¿Qué es SSH (Secure Shell)?

* SSH es el nombre de un protocolo y el programa que lo implementa.
    
* Permite iniciar sesión de forma segura y remota a través de una red.
    
* Principalmente usado en servidores para una administración remota.
    
* Pertenece a la capa de aplicación de los modelos OSI y TCP/IP.
    
* De forma estándar usa el puerto 22.
    
* Considerado el reemplazo de Telnet.
    

# Funcionamiento de llaves públicas y privadas

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675727356270/36245140-2fa0-43c8-b90e-e39912422284.png align="center")

# Configurar RPi

Para configurar el Raspberry Pi, primero debemos habilitar el servidor SSH. Luego, crearemos un nuevo usuario con su respectiva contraseña y lo añadiremos a los grupos `gpio` y `sudo`.

Antes de comenzar la configuración, es importante asegurarse de tener una contraseña segura para el usuario predeterminado del Raspberry Pi. Esto se puede hacer a través de `Inicio > Preferencias > Configuración de Raspberry Pi > Sistema > Cambiar clave`.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675728791205/bb8458b0-948e-4ab8-bcf5-7d6182ca6083.png align="center")

## Habilitar SSH

Existen dos formas comunes de habilitar SSH en el Raspberry Pi: mediante el asistente de configuración o mediante la consola.

### Mediante asistente de configuración

`Inicio > Preferencias > Configuración de Raspberry Pi > Interfaces > SSH`.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675719142928/6ee9f455-4292-4ee1-8136-81e60cd4a4fd.png align="center")

### Mediante consola

```bash
sudo raspi-config
```

Luego, seleccionar `Interface Options ⏎ SSH ⏎ <Yes> ⏎`

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675719529322/00c51045-3ae0-4049-9fec-43ace2ed6f38.png align="center")

## Configurar nuevo usuario

A continuación, crearemos un nuevo usuario con su respectiva contraseña y lo añadiremos a los grupos `gpio` y `sudo`.

### Crear usuario

```bash
sudo adduser juan-remoto
```

<div data-node-type="callout">
<div data-node-type="callout-emoji">☝</div>
<div data-node-type="callout-text">Para nuestro ejemplo el nuevo usuario se llamará <code>juan-remoto</code>, puedes escoger cualquier, pero en los siguientes pasos seguire refiriendome al usuario como <code>juan-remoto</code>.</div>
</div>

Observaciones:

* Se solicitará la contraseña de superusuario.
    
* Luego, se pedirá crear una contraseña para el nuevo usuario.
    
* También se solicitará información adicional del usuario, como el nombre completo o el número de habitación🤷. Esta información puede dejarse en blanco presionando "enter".
    
* Finalmente, se confirmará la información ingresada escribiendo "Y" y presionando "enter".
    

### Añadir a grupos

```bash
sudo usermod -aG gpio,sudo juan-remoto
```

Observaciones:

* El usuario será agregado al grupo `gpio` para acceder a los pines de forma remota.
    
* El usuario también será agregado al grupo `sudo` para ejecutar comandos con permisos de superusuario.
    

## ¿Cuál es mi IP?

Para conectarse de forma remota, es necesario conocer la IP del Raspberry Pi. Esto podemos hacerlo con el siguiente comando:

```bash
hostname -I
```

Observaciones:

* En una red de área local (red doméstica), la IP podría comenzar con `192.168.x.x`.
    
* Es importante recordar esta IP, ya que será necesaria más adelante.
    

# Configurar PC

En primer lugar, es necesario generar un par de llaves pública y privada, y añadir la llave pública al SSH Agent. Luego, copiar la llave pública en el Raspberry Pi.

## Generar par de llaves SSH

```bash
ssh-keygen -t ed25519 -f ~/.ssh/rpi
```

Observaciones:

* Usamos el algoritmo `Ed25519`, el más recomendado en la actualidad.
    
* El par de llaves se llamará `rpi` y se ubicará en `~/.ssh`.
    
* El nombre puede ser modificado según sea necesario, pero en este ejemplo se utilizó `rpi` para identificarlo fácilmente.
    
* Es recomendado crear una `passphrase`, las mejores contraseñas tienen 20 caracteres entre letras mayúsculas, minúsculas, números, y al menos un caracter especial.
    

## Añadir la llave privada a SSH Agent

```bash
ssh-add ~/.ssh/rpi
```

Observaciones:

* Debemos respetar la dirección y el nombre con donde se generaron las llaves.
    
* Si estableciste una `passphrase` se solicitará introducirla.
    

## Copiar la llave pública a RPi

```bash
ssh-copy-id -i ~/.ssh/rpi.pub juan-remoto@192.168.x.x
```

Observaciones:

* Se indica la ruta de la llave pública, entre el par de llaves creados es el que tiene la extension `pub`.
    
* También se indica el usuario, en este caso `juan-remoto`.
    
* La IP debe ser reemplazada por la IP del Raspberry Pi.
    
* Se solicitará la contraseña del usuario `juan-remoto` que fue creado anteriormente.
    

# Configurar VS Code

[Visual Studio Code](https://code.visualstudio.com/) es un editor de código libre que facilita la programación en varios lenguajes. En esta ocasión, lo configuraremos para programar y controlar el GPIO de un Raspberry Pi de forma remota utilizando el protocolo SSH.

## Instalar la extensión [Remote - SSH](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-ssh)

```bash
code --install-extension ms-vscode-remote.remote-ssh
```

<div data-node-type="callout">
<div data-node-type="callout-emoji">☝</div>
<div data-node-type="callout-text">Instalaremos la extension mediante un comando, pero sientete libre de instalarlo directamente en VSCode.</div>
</div>

## Configurar la conexion SSH

Ahora crearemos el archivo de configuración utilizando cualquier editor de texto, como "nano" o "vim". En este ejemplo, utilizaremos "gedit":

```bash
gedit ~/.ssh/config
```

Dentro del archivo, agregaremos la siguiente configuración, reemplazando la IP y el nombre de usuario:

```plaintext
Host rpi-remoto
  HostName 192.168.x.x
  User juan-remoto
```

Guardar y cerrar el archivo.

<div data-node-type="callout">
<div data-node-type="callout-emoji">💡</div>
<div data-node-type="callout-text">La IP del Raspberry Pi puede cambiar si el router se reinicia o por cualquier otro motivo. Si esto ocurre, será necesario actualizar la IP en este archivo.</div>
</div>

## Acceso desde VS Code

Abre VS Code y accede al Raspberry Pi.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675725903327/79bd1f6a-e40f-4b2b-a3ff-fbe9eedf0160.png align="center")

Si se estableció una `passphrase` al generar las llaves, será necesario introducirla.

Espera hasta que se establezca la conexión y luego puedes probar ejecutando algún comando, por ejemplo:

```bash
pinout
```

Obteniendo por ejemplo:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675726958186/919ba16c-6e00-40ef-ab96-53137293ec97.png align="center")

# Outro

En este post, aprendimos cómo utilizar el protocolo SSH para acceder de forma remota a un Raspberry Pi utilizando Visual Studio Code.

* Primero, habilitamos el servicio SSH en el Raspberry Pi y creamos un nuevo usuario con los permisos necesarios.
    
* Después, generamos un par de llaves SSH y copiamos la llave pública en el Raspberry Pi para establecer una conexión segura.
    
* Finalmente, configuramos Visual Studio Code para conectarnos al Raspberry Pi y utilizarlo de forma remota.
    
    ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675729255906/2eddc808-cfa8-4677-a2e1-c9ecd42bcc57.gif align="center")
    

De esta manera, podemos programar un Raspberry Pi de forma remota para proyectos avanzados y ambiciosos. Además, con el protocolo SSH, podemos acceder de forma segura desde cualquier parte del mundo.

Espero que este post haya sido útil y que te haya ayudado a empezar a trabajar con la Raspberry Pi y Visual Studio Code.

# Enlaces

[https://code.visualstudio.com/docs/remote/ssh](https://code.visualstudio.com/docs/remote/ssh)

[https://www.raspberrypi.com/documentation/computers/remote-access.html](https://www.raspberrypi.com/documentation/computers/remote-access.html)

[https://www.ssh.com/academy/ssh/keygen](https://www.ssh.com/academy/ssh/keygen)

[https://es.wikipedia.org/wiki/Secure\_Shell](https://es.wikipedia.org/wiki/Secure_Shell)

%%[saltenha-bo]