Configurar un entorno de desarrollo para Rust y Python
Tags: python, rust, linux
Published: 2019-07-30 05:40:13

Hace unos meses escribí sobre cómo [Integrar Rust a tus proyectos Python](https://dev.to/mattdark/integrar-rust-a-tus-proyectos-python-5ckj) usando [PyO3](https://github.com/PyO3/PyO3), un crate con el que puedes desarrollar módulos nativos de **Python** y ejecutar código **Python** desde Rust.

En este artículo voy a explicar cómo configurar un entorno de desarrollo en distribuciones GNU/Linux para proyectos desarrollados con Python y Rust usando crates como **PyO3** o [CPython](https://github.com/dgrunwald/rust-cpython).

## Requerimientos
Para desarrollar aplicaciones con Rust y Python, podemos usar **PyO3** o **CPython**, ambos con soporte para Python 3.5 y versiones superiores. CPython también tiene soporte para Python 2.7, pero debemos recordar que esta versión del lenguaje dejará de tener soporte el 1 de Enero de 2020.

Python viene instalado por defecto en la mayoría de sistemas GNU/Linux, por lo que no será necesario instalarlo desde los repositorios. Aunque si se requiere otra versión del lenguaje podemos usar [pyenv](https://github.com/pyenv/pyenv).

Estos crates requieren la versión Nightly de Rust. El instalador, **rustup**, está disponible en los repositorios de algunas distribuciones, en caso contrario podemos seguir las instrucciones disponibles en [rustup.rs](https://rustup.rs).

Rust cuenta con un gestor de paquetes, **Cargo**, que nos permite gestionar las dependencias del proyecto, instalado por defecto por **rustup**. Para Python podemos usar [pipenv](https://github.com/pypa/pipenv).

Nota: Cargo muestra un error al intentar ejecutar el binario de la aplicación, al no detectar correctamente la configuración realizada por **pyenv**, por lo que decidí usar la versión del sistema. En cuanto encontré una solucióń, actualizaré el artículo.

## Instalación y Configuración
### Git
Si tenemos nuestro proyecto en un repositorio en Git, debemos instalar git en nuestra distribución.

- Arch Linux
```bash
$ sudo pacman -S git
```

- Ubuntu/Debian
```bash
$ sudo apt install git
```

-Fedora
```bash
$ sudo dnf install git
```

### GCC
Rust requiere un compilador de C instalado, por lo que debemos instalar GCC desde los repositorios.

- Arch Linux
GCC está disponible como paquete individual o en el grupo de paquetes `base-devel`, que además incluye `make`, `binutils`, `fakeroot`, entre otros.

```bash
$ sudo pacman -S gcc
```

```bash
$ sudo pacman -S base-devel
```

- Ubuntu/Debian
GCC está disponible como paquete individual o en el grupo de paquetes `build-essential`.

```bash
$ sudo apt install gcc
```

```bash
sudo apt install build-essential
```

-Fedora
GCC puede instalarse desde los repositorios ejecutando el siguiente comando.

```bash
$ sudo dnf install gcc
```

### Python
Python viene instalado por defecto en la mayoría de las distribuciones, en caso contrario puede instalarse desde los repositorios.

#### pipenv
pipenv es una herramienta que nos permite configurar un entorno virtual para cada proyecto y gestionar las dependencias de maneras más sencilla.

De acuerdo a la documentación disponible en el repositorio de GitHub, **pipenv** puede instalarse desde los repositorios de algunas de las distribuciones más conocidas o usando **pip**.

- Arch Linux
```bash
$ sudo pacman -S python-pipenv
```

- Ubuntu/Debian
```bash
$ sudo apt install pipenv
```

- Fedora
```bash
$ sudo dnf install pipenv
```

- Usando pip
```bash
$ pip install --user pipenv
```

### cURL
En distribuciones en las que el instalador de Rust, rustup, no se encuentra disponible en los repositorios, debemos seguir las instrucciones disponibles en [rustup.rs](https://rustup.rs). Para poder ejecutar correctamente el comando indicado, primero debemos instalar cURL, que en Ubuntu, Debian y derivados no se instala por defecto. Por ello instalamos el paquete desde los repositorios.

```bash
$ sudo apt install curl
```

### Rust
#### Arch Linux
En Arch Linux y derivados, el instalador de Rust, rustup, está disponible desde los repositorios, y puede instalarse ejecutando el siguiente comando en la terminal.

```bash
$ sudo pacman -S rustup
```

Después de instalar rustup, debemos instalar las versiones Stable y Nightly de Rust.

```bash
$ rustup install stable nightly
```

#### Otras distribuciones
En distribuciones en las que el instalador no se encuentra en los repositorios, debemos ejecutar el siguiente comando, según las instrucciones disponibles en [rustup.rs](https://rustup.rs).

```bash
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

El comando anterior descargará el instalador y nos ayudará a instalar las versiones de Rust que necesitamos. En la terminal nos muestra lo siguiente.

```bash
Current instalation options:

  default host triple: x86_64-unknown-linux-gnu
    default toolchain: stable
 modify PATH variable: yes

1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
>
```

La línea `default host triple: x86_64-unknown-linux-gnu` muestra la arquitectura del sistema en el que se está realizando la instalación. En `default toolchain: stable` aparece la versión de Rust que se instalará por defecto.

De las opciones que nos muestra, seleccionamos la número 1, que es la opción por defecto. Para continuar solo presionamos `Enter`.

```bash
  stable installed - rustc 1.36.0 (a53f9df32 2019-07-03)

Rust is installed now. Great!
To get started you need Cargo's bin directory ($HOME/.cargo/bin) in your PATH environment variable. Next time you log in this will be done automatically.

To configure your current shell run source $HOME/.cargo/env
```

Al terminar la instalación nos muestra la versión de Rust instalada y nos indica que debemos agregar el directorio donde se encuentra el binario de Cargo a la variable de entorno `PATH`. Lo cual se hará en automático la próxima vez que abramos la terminal.

Para configurar la terminal actual, ejecutamos el siguiente comando.

```bash
$ source $HOME/.cargo/env
```

Y finalmente instalamos la versión Nightly de Rust.

```bash
$ rustup install nightly
```

Y así hemos terminado de configurar nuestro entorno de desarrollo para Rust y Python. Espero que la información sea de utilidad. En un próximo artículo explicaré un ejemplo práctico de una aplicación web desarrollada con Rust, Python y Firebase.