python - descargar - Activar un virtualenv vía fabric como usuario de implementación

virtualenv install

Question

Quiero ejecutar mi script de tejido localmente, que a su vez, iniciar sesión en mi servidor, cambiar de usuario para implementar, activar los proyectos .virtualenv, que cambiará dir al proyecto y emitirá un git pull.

def git_pull():
sudo(''su deploy'')
# here i need to switch to the virtualenv
run(''git pull'')

Normalmente utilizo el comando workon de virtualenvwrapper que origina el archivo de activación y el archivo postactivate me pondrá en la carpeta del proyecto. En este caso, parece que debido a que el tejido se ejecuta desde dentro del caparazón, el control se cede al tejido, por lo que no puedo usar la fuente de bash incorporada en ''$ source ~ / .virtualenv / myvenv / bin / activate''

¿Alguien tiene un ejemplo y una explicación de cómo lo han hecho?

Answer 1

Aquí hay un código para un decorador que dará como resultado el uso del entorno virtual para cualquier llamada run / sudo:

# This is the bash code to update the $PATH as activate does
UPDATE_PYTHON_PATH = r''PATH="{}:$PATH"''.format(VIRTUAL_ENV_BIN_DIR)
def with_venv(func, *args, **kwargs):
"Use Virtual Environment for the command"
def wrapped(*args, **kwargs):
with prefix(UPDATE_PYTHON_PATH):
return func(*args, **kwargs)
wrapped.__name__ = func.__name__
wrapped.__doc__ = func.__doc__
return wrapped

y luego para usar el decorador, tenga en cuenta que el orden de los decoradores es importante:

@task
@with_venv
def which_python():
"Gets which python is being used"
run("which python")

Answer 2

Como una actualización del pronóstico de bitprophet: con Fabric 1.0 puede usar prefix() y sus propios administradores de contexto.

from __future__ import with_statement
from fabric.api import *
from contextlib import contextmanager as _contextmanager
env.hosts = [''servername'']
env.user = ''deploy''
env.keyfile = [''$HOME/.ssh/deploy_rsa'']
env.directory = ''/path/to/virtualenvs/project''
env.activate = ''source /path/to/virtualenvs/project/bin/activate''
@_contextmanager
def virtualenv():
with cd(env.directory):
with prefix(env.activate):
yield
def deploy():
with virtualenv():
run(''pip freeze'')

Answer 3

En este momento, puedes hacer lo que hago, que es kludgy pero funciona perfectamente * (este uso asume que estás usando virtualenvwrapper, que deberías serlo), pero puedes sustituirlo fácilmente en la llamada ''fuente'' más larga que mencionaste , si no):

def task():
workon = ''workon myvenv && ''
run(workon + ''git pull'')
run(workon + ''do other stuff, etc'')

Desde la versión 1.0, Fabric tiene un administrador de contexto de prefix que usa esta técnica para que pueda, por ejemplo:

def task():
with prefix(''workon myvenv''):
run(''git pull'')
run(''do other stuff, etc'')

* Es probable que command1 && command2 casos en los que el uso del método command1 && command2 pueda explotar, como cuando command1 falla ( command2 nunca se ejecutará) o si command1 no se escapó correctamente y contiene caracteres de shell especiales, y así sucesivamente.

Answer 4

Este es mi enfoque sobre el uso de virtualenv con implementaciones locales.

Utilizando el gestor de contexto path() fabric puede ejecutar pip o python con binarios de virtualenv.

from fabric.api import lcd, local, path
project_dir = ''/www/my_project/sms/''
env_bin_dir = project_dir + ''../env/bin/''
def deploy():
with lcd(project_dir):
local(''git pull origin'')
local(''git checkout -f'')
with path(env_bin_dir, behavior=''prepend''):
local(''pip freeze'')
local(''pip install -r requirements/staging.txt'')
local(''./manage.py migrate'') # Django related
# Note: previous line is the same as:
local(''python manage.py migrate'')
# Using next line, you can make sure that python
# from virtualenv directory is used:
local(''which python'')

Answer 5

Gracias a todas las respuestas publicadas y me gustaría agregar una alternativa más para esto. Hay un módulo, fabric-virtualenv , que puede proporcionar la función como el mismo código:

>>> from fabvenv import virtualenv
>>> with virtualenv(''/home/me/venv/''):
... run(''python foo'')

fabric-virtualenv hace uso de fabric.context_managers.prefix , que podría ser una buena manera :)

Answer 6

Si desea instalar los paquetes en el entorno o desea ejecutar comandos de acuerdo con los paquetes que tiene en el entorno, he encontrado este truco para resolver mi problema, en lugar de escribir métodos complejos de estructura o instalar nuevos paquetes de SO:

/path/to/virtualenv/bin/python manage.py migrate/runserver/makemigrations # for running commands under virtualenv
local("/home/user/env/bin/python manage.py migrate") # fabric command
/path/to/virtualenv/bin/pip install -r requirements.txt # installing/upgrading virtualenv
local("/home/user/env/bin/pip install -r requirements.txt") # fabric command

De esta manera es posible que no necesite activar el entorno, pero puede ejecutar comandos en el entorno.

Answer 7

Solo estoy usando una función de envoltura simple virtualenv () a la que se puede llamar en lugar de ejecutar (). No utiliza el administrador de contexto de CD, por lo que se pueden usar rutas relativas.

def virtualenv(command):
"""
Run a command in the virtualenv. This prefixes the command with the source
command.
Usage:
virtualenv(''pip install django'')
"""
source = ''source %(project_directory)s/bin/activate && '' % env
run(source + command)

Answer 8

virtualenvwrapper puede hacer esto un poco más simple

1. Usar el enfoque de @ nh2 (este enfoque también funciona cuando se usa local , pero solo para instalaciones virtualenvwrapper donde workon está en $PATH , en otras palabras, Windows)

   from contextlib import contextmanager
   from fabric.api import prefix
   @contextmanager
   def virtualenv():
   with prefix("workon env1"):
   yield
   def deploy():
   with virtualenv():
   run("pip freeze > requirements.txt")

2. O despliega tu archivo fab y ejecútalo localmente. Esta configuración le permite activar virtualenv para comandos locales o remotos. Este enfoque es poderoso porque funciona en función de la incapacidad local para ejecutar .bashrc utilizando bash -l :

   @contextmanager
   def local_prefix(shell, prefix):
   def local_call(command):
   return local("%(sh)s /"%(pre)s && %(cmd)s/"" %
   {"sh": shell, "pre": prefix, "cmd": command})
   yield local_prefix
   def write_requirements(shell="/bin/bash -lic", env="env1"):
   with local_prefix(shell, "workon %s" % env) as local:
   local("pip freeze > requirements.txt")
   write_requirements() # locally
   run("fab write_requirements")