Empezando con vagabundo

proyecto LÁMPARA

En este ejemplo, se crea un entorno de desarrollo de proyecto LAMP personalizado con Vagrant.

En primer lugar, deberá instalar Virtual Box y Vagrant.

Luego, cree una carpeta vagrant en su directorio de inicio, abra su terminal y cambie el directorio actual al nuevo directorio vagrant. Ahora, ejecuta vagrant init. Se creará un archivo Vagrantfile dentro y se verá así:

# -*- mode: ruby -*-
# vi: set ft=ruby :

# All Vagrant configuration is done below. The "2" in Vagrant.configure
# configures the configuration version (we support older styles for
# backwards compatibility). Please don't change it unless you know what
# you're doing.
Vagrant.configure(2) do |config|
  # The most common configuration options are documented and commented below.
  # For a complete reference, please see the online documentation at
  # https://docs.vagrantup.com.

  # Every Vagrant development environment requires a box. You can search for
  # boxes at https://atlas.hashicorp.com/search.
  config.vm.box = "base"

  # Disable automatic box update checking. If you disable this, then
  # boxes will only be checked for updates when the user runs
  # `vagrant box outdated`. This is not recommended.
  # config.vm.box_check_update = false

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine. In the example below,
  # accessing "localhost:8080" will access port 80 on the guest machine.
  # config.vm.network "forwarded_port", guest: 80, host: 8080

  # Create a private network, which allows host-only access to the machine
  # using a specific IP.
  # config.vm.network "private_network", ip: "192.168.33.10"

  # Create a public network, which generally matched to bridged network.
  # Bridged networks make the machine appear as another physical device on
  # your network.
  # config.vm.network "public_network"

  # Share an additional folder to the guest VM. The first argument is
  # the path on the host to the actual folder. The second argument is
  # the path on the guest to mount the folder. And the optional third
  # argument is a set of non-required options.
  # config.vm.synced_folder "../data", "/vagrant_data"

  # Provider-specific configuration so you can fine-tune various
  # backing providers for Vagrant. These expose provider-specific options.
  # Example for VirtualBox:
  #
  # config.vm.provider "virtualbox" do |vb|
  #   # Display the VirtualBox GUI when booting the machine
  #   vb.gui = true
  #
  #   # Customize the amount of memory on the VM:
  #   vb.memory = "1024"
  # end
  #
  # View the documentation for the provider you are using for more
  # information on available options.

  # Define a Vagrant Push strategy for pushing to Atlas. Other push strategies
  # such as FTP and Heroku are also available. See the documentation at
  # https://docs.vagrantup.com/v2/push/atlas.html for more information.
  # config.push.define "atlas" do |push|
  #   push.app = "YOUR_ATLAS_USERNAME/YOUR_APPLICATION_NAME"
  # end

  # Enable provisioning with a shell script. Additional provisioners such as
  # Puppet, Chef, Ansible, Salt, and Docker are also available. Please see the
  # documentation for more information about their specific syntax and use.
  # config.vm.provision "shell", inline: <<-SHELL
  #   sudo apt-get update
  #   sudo apt-get install -y apache2
  # SHELL
end

Agregue o descomente las siguientes líneas editando el archivo anterior:

config.vm.box = "hashicorp/precise64"
config.vm.network :forwarded_port, guest: 80, host: 8080
config.vm.network :private_network, ip: "192.168.33.10"
config.ssh.forward_agent = true
if Vagrant::Util::Platform.windows?
  config.vm.synced_folder "./", "/vagrant"
else
  config.vm.synced_folder "./", "/vagrant", type: "nfs"
end
# https://stefanwrobel.com/how-to-make-vagrant-performance-not-suck
config.vm.provider "virtualbox" do |v|
  host = RbConfig::CONFIG['host_os']

  # Give VM 1/4 system memory & access to all cpu cores on the host
  if host =~ /darwin/
    cpus = `sysctl -n hw.ncpu`.to_i
    # sysctl returns Bytes and we need to convert to MB
    mem = `sysctl -n hw.memsize`.to_i / 1024 / 1024 / 4
  elsif host =~ /linux/
    cpus = `nproc`.to_i
    # meminfo shows KB and we need to convert to MB
    mem = `grep 'MemTotal' /proc/meminfo | sed -e 's/MemTotal://' -e 's/ kB//'`.to_i / 1024 / 4
  else # sorry Windows folks, I can't help you
    cpus = 2
    mem = 1024
  end

  v.customize ["modifyvm", :id, "--memory", mem]
  v.customize ["modifyvm", :id, "--cpus", cpus]
end

Edite su archivo hosts para redirigir su dominio deseado a la máquina virtual vagabunda. Para Linux solía ser /etc/hosts, para Windows C:\Windows\System32\Drivers\etc\hosts; y añade esta línea:

192.168.33.10 vagrantServer.com

Por supuesto, puede reemplazar vagrantServer.com con cualquier nombre.

Ahora es el momento de crear el archivo bootstrap.sh (dentro del directorio vagrant). Este script se ejecutará cada vez que se genere la VM desde cero. Lee atentamente los comentarios:

#!/usr/bin/env bash

# .ssh/authorized_keys (you will need to create a `.ssh` directory inside the `vagrant` one and add a file named `authorized_keys` with the public keys of the users who have access to the repository and may use this environment).
# You also will have to grant access to those public keys from the Github account, Bitbucket, or whatever you're using.
cat /vagrant/config/authorized_keys >> /home/vagrant/.ssh/authorized_keys
if ! [ -d /root/.ssh ]; then
  mkdir /root/.ssh
fi
cp /vagrant/config/authorized_keys /root/.ssh
chmod 600 /root/.ssh/authorized_keys

# Install packages
apt-get update
apt-get install -y python-software-properties
add-apt-repository ppa:ondrej/php5 -y
apt-get update
apt-get install -y curl nano apache2 php5 php5-mysql php5-curl php5-gd php5-intl php5-mcrypt git

# Apache2 run with user vagrant
APACHEUSR=`grep -c 'APACHE_RUN_USER=www-data' /etc/apache2/envvars`
APACHEGRP=`grep -c 'APACHE_RUN_GROUP=www-data' /etc/apache2/envvars`
if [ APACHEUSR ]; then
    sed -i 's/APACHE_RUN_USER=www-data/APACHE_RUN_USER=vagrant/' /etc/apache2/envvars
fi
if [ APACHEGRP ]; then
    sed -i 's/APACHE_RUN_GROUP=www-data/APACHE_RUN_GROUP=vagrant/' /etc/apache2/envvars
fi
sudo chown -R vagrant:www-data /var/lock/apache2

# Set user/password to mysql previously to installation
# Replace rootMysqlPassword with your desired MySQL root password
debconf-set-selections <<< 'mysql-server mysql-server/root_password password rootMysqlPassword'
debconf-set-selections <<< 'mysql-server mysql-server/root_password_again password rootMysqlPassword'

# Install mysql
apt-get update
apt-get install -y mysql-server mysql-client

# Link /vagrant (sync_folder) to apache directory (/var/www)
if ! [ -L /var/www ]; then
  rm -rf /var/www
  ln -fs /vagrant /var/www
fi

# Install composer
curl -sS https://getcomposer.org/installer | php
mv composer.phar /usr/local/bin/composer

# Composer example. Uncoment to istall phpunit
#composer global require "phpunit/phpunit=3.7.*" --prefer-source

# Create mysql database (replace "vagrantDB" with any desired database name, and "rootMysqlPassword" with the password set above)
mysql -u root -prootMysqlPassword -v -e "CREATE USER 'developer'@'%' IDENTIFIED BY 'dev'; 
CREATE SCHEMA vagrantDB;
GRANT ALL ON vagrantDB TO 'developer'@'%';"

# Uncomment to set default database fixtures based on `/vagrant/config/vagrantDBFixtures.sql` file.
#mysql -u root -prootMysqlPassword -v vagrantDB < /vagrant/config/vagrantDBFixtures.sql

###################################################
################ THIS IS OPTIONAL #################
###################################################

# Install nodejs
curl -sL https://deb.nodesource.com/setup | sudo bash -
apt-get install -y nodejs

# Install npm packages
npm install -g npm
npm install -g bower
npm install -g forever
npm install -g gulp

# Set accepted license before install java
echo debconf shared/accepted-oracle-license-v1-1 select true | sudo debconf-set-selections
echo debconf shared/accepted-oracle-license-v1-1 seen true | sudo debconf-set-selections

# Install java7
apt-get install -y oracle-java7-installer oracle-java7-set-default

###################################################
################### END OPTIONAL ##################
###################################################

# Generate ssh key without passphrase
ssh-keygen -f /root/.ssh/id_rsa -t rsa -N ""

# Add bitbucket and github to known hosts
touch /root/.ssh/known_hosts
ssh-keyscan -H bitbucket.org >> /root/.ssh/known_hosts
ssh-keyscan -H github.com >> /root/.ssh/known_hosts

# Source: https://gist.github.com/winhamwr/7122947
# Sleep until we can successfully SSH into Bitbucket.
# Uses doublinng backoff while waiting 
# with_backoff() adapted from http://stackoverflow.com/a/8351489
# Retries a command a configurable number of times with backoff.
#
# The retry count is given by ATTEMPTS (default 5), the initial backoff
# timeout is given by TIMEOUT in seconds (default 1.)
#
# Successive backoffs double the timeout.
#generatedKey="`cat /root/.ssh/id_rsa.pub`"
echo -n "Generate a SSH key (https://help.github.com/articles/generating-ssh-keys/) 
and add it to your Bitbucket account (Profile -> SHH keys) to continue. "

with_backoff() {
  local max_attempts=${ATTEMPTS-5}
  local timeout=${TIMEOUT-1}
  local attempt=0
  local exitCode=0
 
  while [ $attempt -lt $max_attempts ]
  do
    set +e
    "[email protected]"
    exitCode=$?
    set -e
 
    if [ $exitCode -eq 0 ]
    then
      break
    fi
 
    echo "Failure! Retrying in $timeout.." 1>&2
    sleep $timeout
    attempt=$(( attempt + 1 ))
    timeout=$(( timeout * 2 ))
  done
 
  if [ $exitCode -ne 0 ]
  then
    echo "You've failed me for the last time! ([email protected])" 1>&2
  fi
 
  return $exitCode
}
 
ATTEMPTS=${ATTEMPTS:-5}
 
export ATTEMPTS
with_backoff ssh -T [email protected];

# Clone repositories (replace "yourProjectName" and "yourProjectRepository" with your project data)
cd /var/www
rm -rf yourProjectName/
git clone yourProjectRepository

# Add server names to /etc/hosts (replace "vagrantServer.com" with the domain set above)
echo -e '\n127.0.0.1       vagrantServer.com' >> /etc/hosts

# Enable apache modes
a2enmod rewrite

# Copy sites-available file (you need to add the Apache configuration file for the desired domain in `config/sites-available`. Replace "vagrantServer.conf" with the desired name)
cp /vagrant/config/sites-available/vagrantServer.conf /etc/apache2/sites-available/

# Remove html from document root
sed -i 's/\/var\/www\/html/\/var\/www/g' /etc/apache2/sites-available/*
service apache2 restart

# Enable sites (replace "vagrantServer.conf" with the above file name)
a2ensite vagrantServer.conf

# Install ruby, compass and sass (Optional)
apt-get install -y rubygems
gem install compass
npm install -g sass

# Pull the repo
cd /var/www/yourProjectName
git pull --all

Una vez que verifique y guarde el archivo anterior, vaya a su terminal nuevamente, cambie el directorio actual al vagrant que ha creado antes y escriba vagrant up. Se creará la VM y se ejecutará el archivo boostrap desde la VM, por lo que se copiarán/instalarán todas las cosas necesarias. Una vez que haya terminado, puede abrir su navegador e ir a vagrantServer.com (o el nombre que le haya dado) y debería ver el contenido servido desde la máquina virtual vagabunda.

También podrá editar los archivos de su proyecto a través del directorio vagrant/yourProjectName y todos los archivos dentro del directorio vagrant se compartirán y sincronizarán entre su host y la máquina virtual vagabunda.

Cargue la imagen de Vagrant Box en Amazon AWS AMI

Tiene una caja vagabunda local que desea cargar en Amazon AWS. Primero, necesitas crear un archivo .box:

vagrant package --base my-virtual-machine

This step should take a while depending on the size of your image. Then, you need to get the .vmdk image from the .box file:

gunzip -S .box paquete.box
paquete tarxf

After this step, you should have 4 new files: package, box-disk1.vmdk, Vagrantfile, and box.ovf. Now, to upload to AWS. Assuming you have a AWS account , create an S3 bucket to store the image on Amazon’s servers. You’re going to need Amazon’s EC2 CLI for the next step (as you can’t do this through the console as far as I can tell):

ec2-import-instance box-disk1_1.vmdk -f VMDK -t t2.micro -a x86_64 -b <S3-bucket-name> -o $AWS_ACCESS_KEY -w $AWS_SECRET_KEY -p Linux

El resultado de este comando debería demorar un tiempo: está cargando el archivo de imagen grande en S3, pero el comando en sí regresa más rápido. Puede verificar el progreso de la importación usando el comando ec2-describe-conversion-tasks.

Una vez que termine, verá una instancia de su caja ejecutándose en la consola de AWS. Sin embargo, es posible que no pueda acceder a él porque no tiene una dirección IP pública y/o no tiene un archivo .pem asociado. Entonces, el siguiente paso es crear una AMI desde la instancia. Para crear una AMI, detenga la instancia (¡no la termine!) y haga clic con el botón derecho en la instancia y vaya a Imagen->Crear imagen. Esto también debería tomar un tiempo. Puede comprobar el progreso en la vista de AMI de la consola. Una vez que finalice, inicie una instancia utilizando la AMI adjuntando un archivo de clave .pem y luego puede ssh y listo.

Instalación para Windows con soporte VirtualBox y SSH

Para usar Vagrant en la plataforma Windows, primero debe instalar el software de virtualización y una herramienta de línea de comandos ssh. Este ejemplo utilizará el software gratuito VirtualBox y Cygwin.

Instalar VirtualBox

Descargue la última versión de VirtualBox desde la página de descarga oficial y ejecute el archivo descargado. Tenga en cuenta que durante la instalación perderá temporalmente la conexión a la red. Advertencia: interfaces de red

También debe permitir que Oracle instale controladores adicionales.

Instalar Cygwin

Consígalo de cygwin.com y ejecute la configuración hasta que obtenga la página “Seleccionar paquetes”.

Solo necesitamos ssh bin-s desde aquí: Paquetes Cygwin SSH

Agregar Cygwin a la RUTA

También debe agregar la carpeta C:\cygwin64\bin a la variable de entorno PATH de Windows. Para que pueda llamar al comando ssh desde cualquier lugar.

Instalar Vagrant en sí mismo

Descarga Vagrant de vagrantup.com y simplemente sigue la guía de configuración para instalarlo. Tienes que reiniciar tu computadora después de esto.

Pruebas

La tecnología de virtualización VTx/VTd debe estar habilitada. (Puedes encontrar eso en el BIOS en las opciones de seguridad)

Para probar si todo se instaló correctamente, cree una carpeta vacía en algún lugar del disco duro, abra la línea de comando y muévase a la carpeta que acaba de crear:

cd c:/path/to/your/folder

entonces entra

vagrant init hashicorp/precise64
vagrant up

Esto creará e iniciará VirtualBox con Ubuntu 12.04 LTS de 64 bits. Para iniciar la versión de 32 bits, use vagrant init hashicorp/precise32. Si necesita otra caja, puede encontrar más en el sitio web de hashicorp.

Además, el comando vagrant init creará un archivo de configuración Vagrantfile en la carpeta actual. Ahora simplemente puede enviarlo a otra persona y cuando esa persona llame a vagrant up, se creará exactamente la misma máquina virtual en su PC.

Para probar ssh después de que estos dos comandos se ejecuten correctamente, ejecute este comando en la misma carpeta:

vagrant ssh

Si todo salió bien, terminará dentro de la máquina virtual conectado como el usuario ‘vagabundo’.

Pasos adicionales

Puede detener la máquina virtual con

vagrant halt

o eliminarlo con

vagrant destroy

Más cuadros junto con las instrucciones de cómo instalarlos se pueden encontrar en la página vagrantbox.es.

La forma más fácil de tener un linux virtual en solo unos minutos (en 3 pasos)

Paso 1.

En su máquina host (Windows/Linux/OSX), cree un directorio vacío my_project.

Paso 2.

Cree un archivo llamado Vagrantfile con esto:

Vagrant.configure("2") do |config|
  config.vm.box = "gbarbieru/xenial" #An Ubuntu 16.04 based image
  config.vm.hostname = "my_project"
  config.vm.network :private_network, ip: "172.16.123.10"
end

Paso 3.

Ejecute su máquina:

host$ vagrant up
host$ vagrant ssh
virtual$ cd /vagrant

¡Hecho!


Notas:

  • Tal vez quiera asignar otra dirección IP.
  • Si su host es Windows, tal vez quiera hacer ssh desde putty. Puede hacerlo ssh-ing al nombre de host 127.0.0.1 y puerto 2222. El nombre de usuario es vagrant y la contraseña es vagrant.

sincronizando todas las carpetas

Para sincronizar todas las carpetas en ambas direcciones, inserte esto en su Vagrantfile

config.vm.synced_folder "my-project1", "/home/vagrant/my-project1"

sincronizando carpetas pero excluyendo algunas carpetas

Para sincronizar todas las carpetas en ambas direcciones, inserte esto en su Vagrantfile:

config.vm.synced_folder "my-project1", "/home/vagrant/my-project1", type: "rsync",
 :rsync__exclude => ['my-project1/mini_project2/target,my-project1/mini_project2/target,my-project1/mini_project3/target']

Todas las carpetas de destino están excluidas de la sincronización. La sincronización solo ocurre en vagrant up y en vagrant reload. Para sincronizar cada cambio de su host a invitado, debe usar:

vagrant rsync-auto