Iniciando con Virtualenv

(Imagen: pexels.com/photo/person-holding-photo-of-plant-2769188 )

En el post de las diferentes herramientas para crear entornos virtuales en Python mencione que Pipenv cuenta con varias ventajas y es cada vez más utilizado en el mundo del desarrollo Python. Aun así puede ser una opción algo compleja para quien recién comienza. Quizás, lo mejor es comprender como funciona Pip y Virtualenv por separado antes de adentrarse al uso de herramientas más complejas. En este articulo me centrare en explicar el uso de Virtualenv.

En este articulo veras:

• Propósito de la herramienta
• Instalación
• Creando un entorno virtual
• Activando el entorno virtual
• Instalando paquetes en Virtualenv
• Trabajando con Virtualenv
• Estructura del entorno virtual
• Desinstalando paquetes
• Automatizando un poco el trabajo
  • Creando requirements.txt
  • Usando requirements.txt
• Desactivar el entorno virtual
• Conclusión

Propósito de la herramienta

Esta herramienta fue pensada para poder desarrollar diferentes proyectos en Python con diversas versiones de paquetes, evitando que entren en conflicto. Por ejemplo, si un programador quiere realizar dos proyectos, uno con Django 1.11 y otro con 2.1, se encontrara con conflictos entre las dependencias instaladas para cada versión, problema que se evitaría al usar entornos virtuales. Virtualenv nos permite crear estos entornos aislados para Python, en los cuales es posible instalar paquetes sin afectar otros virtualenvs ni los paquetes de Python del sistema.

Instalación

Para instalar la utilidad virtualenv se puede utilizar el gestor de paquetes de las diferentes distribuciones Linux:

# Red Hat y distribuciones basadas en este
$ sudo yum install python-virtualenv python37-virtualenv

# Debian o Ubuntu y sus derivados
$ sudo apt-get install python-virtualenv virtualenv

También podrías usar pip (el cual viene con Python) para instalar viertualenv. No hay una razón especial pero prefiero usar el gestor estándar en lugar de pip.

Creando un entorno virtual

Una vez más, un entorno virtual es como una caja de arena, que contiene solo los paquetes que eliges e ignora (por defecto) todos los paquetes de Python instalados en cualquier otro lugar de su sistema. En lo personal, al trabajar con virtualenv, me gusta ponerlos todos en una misma carpeta, pero cada entorno virtual reside en un directorio dedicado.

~/webDeveloper/misVirtualenvs
  ├── OpenDogEnv/
  ├── SingularEnv/
  ├── WebtoolsEnv/
  └── OtherEnv/

Para esto te diriges en la terminal al lugar donde deseas tener todos tus futuros virtualenv, creas la carpeta ingresas a ella.

$ mk misVirtualenvs && cd misVirtualenvs

Por si no lo sabes, el "&&" permite en la terminal encadenar comandos.

Ahora crearemos el entorno virtual propiamente dicho, nota que en el siguiente comando se aclara explícitamente que este sea python 3.x, de lo contrario se creara con python 2.7 (el cual desde 2020 ya no cuenta con soporte).

$ virtualenv nombreEnv --python=python3

Activando el entorno virtual

Una vez creado el entorno virtual solo queda activarlo para poder hacer uso de el. Esto es muy importante, ya que de lo contrario toda acción que realices, como instalar paquetes Python, sera sobre el sistema y no con relación a tu proyecto.

$ source nombreEnv/bin/activate

El prompt en la terminal cambiara a:

(nombreEnv)$ 

Indicando que el mismo esta activo. Ahora ejecutaremos un comando con pip el cual nos indicara los paquetes python que tenemos instalados dentro de el entorno.

(nombreEnv)$ pip freeze

Este nos retornara algo como:

pkg-resources==0.0.0

Que es el pakage que siempre se encuentra por defecto.

Instalando paquetes en Virtualenv

Para instalar y gestionar cualquier paquete en dentro de el se utiliza pip. Es importante recordar que usar cualquier otro gestor ejecutara fuera del env las peticiones que se realicen. Con el siguiente comando instalaremos un paquete, en este caso el framework Django como ejemplo.

(nombreEnv)$ pip install Django==2.1

Esto iniciara la descarga del package así como de las dependencias del mismo y luego la instalación.

Collecting Django==2.1
  Downloading https://files.pythonhosted.org/packages/51/1a/e0ac7886c7123a03814178d7517dc822af0fe51a72e1a6bff26153103322/Django-2.1-py3-none-any.whl (7.3MB)
     |████████████████████████████████| 7.3MB 585kB/s 
Collecting pytz (from Django==2.1)
  Using cached https://files.pythonhosted.org/packages/87/76/46d697698a143e05f77bec5a526bf4e56a0be61d63425b68f4ba553b51f2/pytz-2019.2-py2.py3-none-any.whl
Installing collected packages: pytz, Django
Successfully installed Django-2.1 pytz-2019.2

Trabajando con Virtualenv

Bien, ya tenemos instalado el paquete, en este caso Django, dentro de nuestro entorno virtual. Pero aun no lo usamos. Personalmente, me gusta poner todos los proyectos en los cuales trabajo en una única carpeta a parte de los virtualenv.

~/webDeveloper
  ├── /misVirtualenvs
  | ├── OpenDogEnv/
  | ├── SingularEnv/
  | ├── WebtoolsEnv/
  | ├── OtherEnv/
  | └── nombreEnv/ # Nuevo env
  | 
  └── /misProjects
    └── nombreProj/ # Nuevo proyecto

Son solo gustos, bien podrías poner el proyecto en la misma carpeta del env.

Crea la carpeta que contendrá los futuros proyectos.

(nombreEnv)$ cd ..
(nombreEnv)$ mk misProjects && cd misProjects

Nota que en este caso particular retrocedimos un nivel, así la nueva carpeta queda fuera de misVirtualenvs.

Ahora creo un nuevo proyecto Django con su correspondiente comando.

(nombreEnv)$ django-admin startproject miNuevoProyecto

La estructura del cual quedaría así.

└── miNuevoProyecto
    ├── manage.py
    └── miNuevoProyecto
        ├── __init__.py
        ├── settings.py
        ├── urls.py
        └── wsgi.py

Estructura del entorno virtual

Supongamos que quieres agregar una aplicación de terceros a tu proyecto Django, en este caso Django Extensions, para ello utilizamos pip:

(nombreEnv) $ pip install django-extensions

Listo, si quieres ver el package y sus dependencias instaladas ejecuta:

(nombreEnv)$ pip freeze

Y obtendrás algo parecido a esto:

Django==2.1
django-extensions==2.2.1
pkg-resources==0.0.0
pytz==2019.2
six==1.12.0

¿Pero donde fue a parar la aplicación? No aparece en la carpeta de proyecto Django.

No te confundas, la aplicación en ningún momento se coloca en el directorio de tu proyecto. Al ejecutar el comando pip el viertualenv activo "captura la orden" e instala la aplicación dentro de el, en la carpeta que se creo, "nombreEnv".

Esta es la estructura de nuestro entorno.

nombreEnv/
  ├── bin/
  ├── include/
  ├── share/
  └── lib/
    └── python3.7/
        └── site-packages/

Los ejecutables para interactuar con en entorno se encuentran en el directorio bin/. En el directorio include/ se encuentran archivos necesarios para compilar algunas librerías de Python. share/ contiene los paquetes estándar. En el directorio lib/ se encuentra una copia de la instalación de Python, ademas contiene el directorio llamado site-packages/, es allí donde se almacenan los paquetes Python instalados con pip.

Pero no te preocupes, esto es solo para tener una noción de como funcionan las cosas, jamas tendrás que meter mano aquí.

Desinstalando paquetes

Puedes usar pip para quitar los packages que no necesites o instalaste por error, un ejemplo seria:

(nombreEnv) $ pip unistall django-extensions

Ten en cuenta que esto no quitara las dependencias, y considera el peligro de quitar estas, ya que pueden ser utilizadas por otras herramientas. Si quieres, antes de desinstalar el package, puedes ver los datos de este y sus dependencias con:

(nombreEnv)$ pip show django-extensions

Automatizando un poco el trabajo

Cada vez que comienzas un proyecto creas su correspondiente env y puedes necesitar instalar una y otra vez las mismas herramientas. Una forma de agilizar esta tarea y salvar algo de tiempo es utilizar un archivo requirements.txt, este es tan solo un archivo de texto que contiene lo necesario para llevar adelante tu proyecto.

El fichero .txt puede tener cualquier nombre, aunque se acostumbra llamarlo simplemente "requirements" para identificarlo con rapidez.

Crear requirements.txt

Para crear este archivo basta con ejecutar:

(nombreEnv)$ pip freeze > requirements.txt

Y el archivo se creara en el directorio en donde nos encontremos en ese momento. Un buen lugar para colocarlo es en la raíz de nuestro trayecto.

El requirements.txt no solo sirve para ahorrar trabajo, también te sera útil para llevar tu proyecto a otro env o a producción, así como para compartir tu proyecto con otros desarrolladores.

Si abres el archivo veras algo como esto:

# Contenido requirements.txt
Django==2.1
django-extensions==2.2.1
pkg-resources==0.0.0
pytz==2019.2
six==1.12.0

Algo interesante, y que también puedes utilizar durante la instalación manual, es elegir que versión precisas de cada paquete:

Django      # Instala la ultima versión disponible 
Django==2.1 # Instala exactamente esa versión
Django>=2   # Instala una versión mayor que o igual a 2

Usando requirements.txt

Puedes hacer uso de este fichero en un entorno nuevo con el comando:

(otroEntornoEnv)$ pip install -r requirements.txt

Desactivar el entorno virtual

Esto lo deje para el final, ya que es un error muy común desactivarlo y empezar a trastear sin darse cuenta que no se esta trabajando dentro de el. Desde cualquier lugar donde te encuentres ejecuta el comando:

(nombreEnv)$ deactivate

Y el (nombreEnv) desaparecerá del prompt indicando que estas "fuera".

Ahora que esta desactivado ejecuta una vez más el comando:

$ pip freeze

Notaras que aparece una lista mucho más grande de paquetes instalados, estos son los propios del sistema operativo y Python. Mientras el env esta activado estos técnicamente no existen para el.

Conclusión

Bueno, como veras puede verse complicado pero en realidad es muy simple, y es bueno familiarizare con estas herramientas ya que casi todos las plataformas de desarrollo tienen sus equivalentes.

Para más informacion puedes visitar: La documentación oficial de pip. Y la documentación oficial devirtualenv.

A un paso más de Virtualenv esta Virtualenvwrapper, el cual automatiza muchos de las cosas que hicimos aquí, y aun más lo hace Pipenv.

Espero haber abarcado todo punto iportante y haber sido lo suficientemente didactico

Written by @EspiFreelancer with StackEdit.