Activar un virtualenv a través de fabric como usuario de implementación

Como una actualización del pronóstico de bitprophet: Con Fabric 1.0 puede hacer uso de prefix() y sus propios gestores 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')

Solo estoy usando una función de envoltura simple virtualenv() que se puede llamar en lugar de run(). 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)

virtualenvwrapper puede hacer esto un poco más simple

1. Usando 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 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 implemente su archivo fab y ejecútelo localmente. Esta configuración le permite activar el virtualenv para comandos locales o remotos. Este enfoque es poderoso porque funciona alrededor de la incapacidad de local para ejecutarse .bashrc usando 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")
   

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

Usando el gestor de contexto path() de fabric puedes 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')

Gracias a todas las respuestas publicadas y me gustaría añadir 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:)

Aquí está el código para un decorador que resultará en el uso de 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")

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 fabric o instalar nuevos paquetes de sistema operativo:

/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 bajo el entorno.