Hacer backups de datos con Ansible en Linux y Windows (Parte 1)

En este post voy a explicar como conectarte con Ansible a una maquina windows y otra linux (parte 2) para realizar backups. En mi empresa Genera Games gestiono todos los procesos con un proyecto de Python al que he bautizado como Professor-X. Cada módulo del proyecto es un miembro de la Imposible Patrulla X, que realiza una tarea específica. En este post voy a hablar de Wolverine, que se encarga de gestionar los backups en mi oficina.

El primer paso es crearte tu entorno virtual de Python 3 con el comando virtualenv wolverine -p python3 . Una vez instalado hay que instalar las siguientes dependencias:

Ahora podemos probar a hacer un playbook pequeño que se conecte  al windows que hayas elegido y haga un ipconfig. El playbook pb-wintest-data.yml tendría el siguiente contenido:

En hosts ponemos el nombre del grupo de maquinas a  las que vayamos a acceder, que luego utilizaremos para listar las ip de las mismas. Ese mismo nombre se utiliza luego en el directorio group_vars para definir variables que afecten a ese grupo de maquinas. El fichero inventory contendrá la siguiente información:

En la carpeta group_vars deberías tener un fichero all.yml que serán variables comunes a todos los playbooks y un fichero wintest.yml cuyo contenido debe ser:

Aún me queda averiguar como configurar Active Directory para que admita ssl y valide el certificado. Por ahora lo haremos “inseguro”. Si intentamos ejecutar el playbook con  ansible-playbook -i ../inventory pb-wintest-data.yml -vvvv. Pongo “-vvvv” porque quiero que salga toda la información posible de los errores que no van a salir hasta que ya funcione, cuando funcione no ponemos nada para evitar logs largos. La salida que os debería dar es la siguiente:

Para arreglar este error tenemos que llevar a cabo varios pasos:

  • Habilitar en el firewall de la maquina destino los puertos de Windows Remote Management (puertos 5985 y 5986). Para eso entramos en la configuración avanzada del Firewall de Windows.
  • Ejecutar el script que proporciona ansible para configurar un host de windows para la administración remota ConfigureRemotingForAnsible.ps1
  • En nuestro caso como aún no hemos configurado certificados ni tráfico seguro debemos ejecutar también el comando:  winrm set winrm/config/Service '@{AllowUnencrypted = "true"}'  para comprobar que ha funcionado imprimimos la configuración del winrm con el comando  winrm get winrm/config

Si todo ha funcionado deberíamos ver el resultado de ejecutar en la máquina remota el comando ipconfig /all.

Una vez establecida la conexión vamos a hacer lo que a priori parece sencillo: nos conectamos a la maquina remota, comprimimos lo que queremos guardar en un zip y hacemos un rsync a una máquina que hayamos elegido para guardar nuestros backups. Pero en windows esto puede ser un poco lioso, para empezar si intentamos hacer un rsync del tirón vamos a obtener un error en powershell. Para conseguir rsync, debemos instalar cygwin y para conseguir instalarlo debemos instalar chocolatey. Chocolatey es un gestor de paquetes para windows y tiene un rol en ansible (win_chocolatey) que permite hacer fácil su instalación por lo que vamos a empezar a añadir a playbook mas tasks.

La segunda task la utilizaremos bastante para obtener información de lo que hay instalado y de lo que se han instalado. Ahora tenemos que instalar el cygwin y el cyg-get para poder instalar paquetes adicionales en cygwin

Una vez hecho esto instalamos el openssh y el rsync para poder realizar el rsync por ssh. Además debemos crear un enlace simbólico desde la ruta del home del user del ordenador a la del user de cygwin para poder hacer los rsync.

Con esto ya estamos preparados para poder hacer un rsync a otra maquina por ssh. Nos falta instalar un software de compresión de ficheros que sea sencillo de manejar por linea de comandos, he escogido el 7zip. Lo instalamos igualmente con chocolatey y lo añadimos al path.

Para comprimir voy a utilizar un script de ps1 que he encontrado en github. Se puede utilizar para hacer backups incrementales o como en mi caso completo siempre, para lo cual hay que borrar un fichero que guarda por donde habiamos dejado el incremental de nombre backupconfig.ini

Ahora ya solo falta hacer el rsync propiamente dicho para ello tenemos que realizar dos pasos previos: primero creamos las claves ssh para el usuario de esa máquina ya que la clave publica deberá ser alojada en al maquina hacia la que vamos a hacer el rsync como authorized_keys y segundo añadimos la fingerprint de la maquina destino al known_hosts de la maquina origen, para ello utilizamos la siguiente task.

Para crear la clave ssh utilizamos el comando  ssh-keygen -t rsa -b 4096  el contenido del fichero id_rsa.pub ira al fichero .ssh/authorized_keys de la maquina destino. Con esto podremos realizar el rsync sin que nos solicite contraseña. Finalmente realizamos el rsync de los ficheros 7z que contenga la carpeta backup y los borramos una vez haya terminado

Y hasta aquí como hacer en Windows los bacukps con Ansible. En la parte 2 veremos como hacerlo en linux que es mucho mas sencillo 🙂

Referencias

  • http://docs.ansible.com/ansible/intro_windows.html
  • https://github.com/traschke/7z-backup/blob/master/backup.ps1
  • https://github.com/ansible/ansible/blob/devel/examples/scripts/ConfigureRemotingForAnsible.ps1
  • http://www.virtualtothecore.com/en/configuring-windows-machines-for-ansible/
  • http://www.techrepublic.com/blog/the-enterprise-cloud/set-the-powershell-execution-policy-via-group-policy/
  • https://www.404techsupport.com/2012/10/use-group-policy-to-allow-ping-and-remote-management-on-windows-7/
  • https://wyssmann.com/my-first-steps-with-ansible/
  • http://nokitel.im/index.php/2016/11/09/how-to-manage-windows-server-2016-with-ansible/
  • https://github.com/diyan/pywinrm
  • https://github.com/spencergibb/ansible-osx
  • https://github.com/ultimateboy/ansible.osx
  • https://github.com/lafarer/ansible-role-osx-defaults
  • https://github.com/geerlingguy/ansible-role-nodejs/issues/30
  • https://github.com/mas-cli/mas/issues/70
  • https://blog.vandenbrand.org/2016/01/04/how-to-automate-your-mac-os-x-setup-with-ansible/
  • https://github.com/ansible/ansible/issues/16478
  • http://www.grouppolicy.biz/2014/05/enable-winrm-via-group-policy/
  • http://oriolrius.cat/blog/2015/01/29/ansible-and-windows-playbooks/
  • https://github.com/Homebrew/brew/blob/master/docs/How-to-Create-and-Maintain-a-Tap.md
  • https://blog.vandenbrand.org/2016/01/04/how-to-automate-your-mac-os-x-setup-with-ansible/
  • http://docs.ansible.com/ansible/playbooks_best_practices.html
  • http://answers.unity3d.com/questions/1280198/unable-to-list-target-platforms-cant-build-into-an.html
  • https://social.msdn.microsoft.com/Forums/windowsserver/en-US/fb154aea-33ee-4182-a345-66f88a6769bc/allowunecrypted-winrm-property?forum=windowssecurity
  • https://www.groovypost.com/howto/join-a-windows-10-client-domain/

 

Backing up data with Ansible in Linux and Windows (Part 1)

In this post I will explain how to connect to a windows/linux machine using Ansible  to make backup copies of your data. In my company, Genera Games, I managed all the processes with a Python project called Professor-X. Each module of the project is a member of the X-Men, which performs a specific task. In this post I am going to talk about Wolverine, who is in charge of managing the backups in my office.

The first step is to create a Python 3 virtual environment with the following command  virtualenv wolverine -p python3 . Once installed you must install the following dependencies:

Now we can try to make a small playbook that connects to the windows you have chosen and do an ipconfig. The playbook pb-wintest-data.yml would have the following content:

In hosts we put the name of the group of machines to which we are going to access, then we will use this name to list the ip of the same ones. That same name is then used in the group_vars directory to define variables that affect that group of machines. The inventory file will contain the following information:

In the group_vars folder you should have an all.yml file that will be variables common to all the playbooks and a wintest.yml file whose content should be:

I still have to figure out how to configure Active Directory to support ssl and validate the certificate. For now we will make it “insecure”. Now try to run the playbook with ansible-playbook -i ../inventory pb-wintest-data.yml -vvvv. I put “-vvvv” because I want all the possible information to come out of the errors that are not going to come out until it works, usually we do not put anything to avoid long logs. The output that should give you is the following:

To fix this error we have to following several steps:

  • Enable Windows Remote Management ports (ports 5985 and 5986) in the firewall of the target machine. For that we enter the advanced configuration of the Windows Firewall.
  • Run the script that ansible provides to configure a windows host for remote administration ConfigureRemotingForAnsible.ps1
  • In our case, as we have not yet configured any certificates or secure traffic, we must also execute the command:  winrm set winrm/config/Service '@{AllowUnencrypted = "true"}'  To check that it worked, we printed the winrm configuration with the command winrm get winrm/config

If everything has worked, we should see the result of executing the command on the remote machine ipconfig /all.

Once the connection is established, we will do what a priori seems simple: we connect to the remote machine, compress what we want to keep in a zip file and rsync to a machine that we have chosen to save our backups. But in windows this can be a bit messy, to begin with if we try to do a rsync of the pull we’re going to get an error in powershell. To get rsync, we must install cygwin and to get it installed we must install Chocolatey. Chocolatey is a package manager for windows and has a role in Ansible (win_chocolatey) that allows easy installation so we are going to start adding more tasks to the playbook.

The second task will be used a lot to obtain information about what is installed and what has been installed. Now we have to install cygwin and cyg-get in order to install additional packages in cygwin.

Once this is done we install the openssh and the rsync to be able to perform the rsync by ssh. We must also create a symbolic link, from the home path of the user of the computer to the cygwin user, to be able to do the rsync.

With this we are ready to make an rsync to another machine by ssh. We need to install a file compression software that is easy to use by command line, I have chosen the 7zip. We install it equally with chocolatey and add it to the path.

To compress I will use a ps1 script that I found on github. It can be used to make incremental backups or full backup. That’s my case, for which you have to delete a file that stores where we left the incremental backup, name backupconfig.ini

Now we only need to do the rsync itself, so we have to do two previous steps: first we create the ssh keys for the user of that machine, the public key must be hosted on the machine to which we are going to do the rsync as authorized_keys and we need to add the fingerprint of the destination machine to the known_hosts of the source machine, for this we use the following task.

To create the ssh key we use the command  ssh-keygen -t rsa -b 4096  the contents of the file id_rsa.pub will go to the file .ssh / authorized_keys folder of the destination machine. With this we can perform the rsync without asking for a password. Finally we perform the rsync of the 7z files that contain the backup folder and delete them once finished

And here’s how to make backups with Ansible on Windows. In part 2 we will see how to do it in Linux that, is much simpler 🙂

References

  • http://docs.ansible.com/ansible/intro_windows.html
  • https://github.com/traschke/7z-backup/blob/master/backup.ps1
  • https://github.com/ansible/ansible/blob/devel/examples/scripts/ConfigureRemotingForAnsible.ps1
  • http://www.virtualtothecore.com/en/configuring-windows-machines-for-ansible/
  • http://www.techrepublic.com/blog/the-enterprise-cloud/set-the-powershell-execution-policy-via-group-policy/
  • https://www.404techsupport.com/2012/10/use-group-policy-to-allow-ping-and-remote-management-on-windows-7/
  • https://wyssmann.com/my-first-steps-with-ansible/
  • http://nokitel.im/index.php/2016/11/09/how-to-manage-windows-server-2016-with-ansible/
  • https://superuser.com/questions/221136/bypass-a-licence-agreement-when-mounting-a-dmg-on-the-command-line
  • https://github.com/diyan/pywinrm
  • https://github.com/spencergibb/ansible-osx
  • https://github.com/ultimateboy/ansible.osx
  • https://github.com/lafarer/ansible-role-osx-defaults
  • https://github.com/geerlingguy/ansible-role-nodejs/issues/30
  • https://github.com/mas-cli/mas/issues/70
  • https://blog.vandenbrand.org/2016/01/04/how-to-automate-your-mac-os-x-setup-with-ansible/
  • https://github.com/ansible/ansible/issues/16478
  • http://www.grouppolicy.biz/2014/05/enable-winrm-via-group-policy/
  • http://oriolrius.cat/blog/2015/01/29/ansible-and-windows-playbooks/
  • https://github.com/Homebrew/brew/blob/master/docs/How-to-Create-and-Maintain-a-Tap.md
  • https://blog.vandenbrand.org/2016/01/04/how-to-automate-your-mac-os-x-setup-with-ansible/
  • http://docs.ansible.com/ansible/playbooks_best_practices.html
  • http://answers.unity3d.com/questions/1280198/unable-to-list-target-platforms-cant-build-into-an.html
  • https://social.msdn.microsoft.com/Forums/windowsserver/en-US/fb154aea-33ee-4182-a345-66f88a6769bc/allowunecrypted-winrm-property?forum=windowssecurity
  • https://www.groovypost.com/howto/join-a-windows-10-client-domain/

 

Build a NodeJS stack with TypeScript, ExpressJS, MongoDB, AngularJS

I’m writing this post to those who want to start a new Node.js project and also wants to understand how it works and connects all the elements, without using a preset stack.

Let’s star for the basics, I use the Webstorm IDE from JetBrains, it’s awesome, all the source code will be uploaded in this repo: https://github.com/Squallium/node-express-typescript, I’ll try to use git-flow and also I will deploy the project in Heroku at important milestones

Firstly we’re going to create a basic node project structure with ExpressJS framework, to do this I use the WebStorm’s wizard, but you can use express-generator.  Once it’s created and you’ve checked it’s working we’re going to deploy it in heroku. You need to install the heroku toolbelt by following this instructions heroku setup

In order to let know heroku how to run our project we need to create a Procfile in the root of our app. If you’re using WebStorm, is similar to the www file inside the bin directory. We’re going to create a new file named pre-prod-env.ts with the following content.

The Profile file will contains:

After that, we’re going to create a git repo, and also add two different remotes, one for github, and the other one for heroku.

If everything it’s correct, you should have your source code in your repo (GitHub, BitBucket…) and also you’re app up and woking in heroku opened in your default browser 🙂

I use Admin-LTE as a template for my app. Because my template engine is Jade, I’m also porting to Jade the Admin-LTE project. In order to make all this things work, we’re going to cover a few dependencies. Let’s start by installing admin-lte as a module in our project.

You can copy my views directly from my project, but if you try to run it, you’ll see an ugly website without CSS. Admin-LTE needs some external libraries like JQuery or Fon-Awesomes to work. To install those dependencies we’re going to use the nicest third-party dependencies manager, bower. Let’s star with bootstrap, first we install the bower module npm install --save bower , then we initalize the bower.json config file, with the wizard  bower init . Finally  we install bootstrap,  bower install bootstrap --save . We need to be sure that our app has access to the bower_components folder, simply add these lines in the app.js file and publish this path. 

The last thing, It’s make sure that your project will deploy its third party dependencies like the Node JS ones. We need to add this line into the “scripts” section inside the package.json file:  "postinstall": "./node_modules/bower/bin/bower install" , with this line, when you deploy your code, the npm install command will install the node and bower dependencies. The rest of the necessary bower modules are in my github repo, you can copy and paste the dependencies from the bower.json file.

Looks better now, but still not perfect. What is wrong? It’s simple, my templates now have what they need from browser, but still need some files from the admin-lte module. We need to allow the project access to the admin-lte files, adding the following line in the app.js file.

Now that we have a better look and some forms, let’s fix the routes so we can see them. In the users.ts file inside the routes folder.

As a login strategy we’re going to use the passport module. In this first stage we’re only going to make sure is working without problems. Also we’ll use mongodb for storing the login’s data, if you don’t have mongodb installed read the following instructions  Install MongoDB. Now we need to add passport as a dependency in your project and also a middleware for the sessions.

After that, we have to initialize passport inside our app.ts and also the session management.

Now we need to connect our project with the mongodb database. For the different environments configurations (test, dev, prod) I’m going to use a configuration file like the following config.ts.

And in our app.ts file, we initialize the database depending on the environment, and we need the mongoose module  npm install --save mongoose :

Once we have mongoose connected, we’re going to integrate the local login strategy using passport, and specifically we install the node module passport-local  npm install --save passport-local. First thing we need is create a model to store the data of the different login strategies. Also we’re going to cipher the passwords using bcrypt  npm install --save bcrypt-nodejs.

Now we’re going to create a file that will contain all the management of the different login strategies. Create a passport.ts file in the config folder with the following content.

And then we include it in the setup process of our app.ts this way.

Now we have to define the routes of our app. We’re going to use express.Router(). The basic GET routes are: “/”, “/login”, “/signup”, “/logout” and “/profile”. This last one use a helper function that allow us to know if the user is authenticated or not ir order to show the info.

Now if you run your app, you must be able to sign-up, login and see your profile. In the next post I’ll continue adding features to my app.

Referencias:

Construir un Stack de NodeJS con TypeScript, ExpressJS, MongoDB, AngularJS (Parte 1)

Este post va dirigido a aquellos que quieran comenzar un proyecto en NodeJS y quiera entender como funcionan y se conectan todos los elementos entre sí, sin utilizar un Stack ya predefinido.

Empezamos por lo básico, yo utilizo el IDE Webstorm de JetBrains y todo el código de post estará alojado en este repositorio https://github.com/Squallium/node-express-typescript, utilizo git flow o lo intento 🙂 y además iré desplegando en heroku el proyecto a medida que llegue a lo que considere puntos de inflexión o cosas que deberíamos probar 🙂

En primer lugar vamos a crear una estructura básica de un proyecto de NodeJS con ExpressJS para ello yo en mi caso utilizo el wizard de de WebStorm, si no es vuestro caso podéis utilizar express-generator. Una vez creado y comprobado que arranca vamos a desplegarlo en heroku. Debéis tener instalado heroku toolbelt si no es así podeís instalarlo siguiendo las instrucciones de la pagina de heroku setup

Para que heroku pueda arrancar nuestro proyecto debemos crear en la raiz del mismo un fichero Procfile que inicie  la aplicación. Si estas usando WebStorm, este fragmento de código esta en la carpeta bin un fichero llamado www. Nosotros vamos a crear uno a parte que llamaremos pre-prod-env.jsy que tendrá el siguiente contenido.

El fichero Profile tendrá el siguiente contenido.

Una vez hecho esto, nos colocamos en la carpeta del proyecto, vamos a crear un repositorio de git, añadirle nuestro remoto (en mi caso de github) y luego desplegarlo en heroku.

Después de esta ristra de código, deberíamos por un lado tener en nuestro repositorio subido a (GitHub, BitBucket…) y nuestra aplicación subida a heroku y abierta en el navegador 🙂

Voy a utilizar Admin-LTE como template para la aplicación. Como mi motor de templates es Jade, además estoy portando a Jade el Admin-LTE. Para ello vamos a necesitar un buen numero de modulos y librerías externas.  En primer lugar vamos a instalar admin-lte como modulo de nuestro proyecto de node.

Podéis copiar directamente las vistas de mi proyecto, pero si intentáis arrancar solo veréis una web sin css un poco fea. Admin-LTE precisa de una serie de librerías como JQuery o Font-Awesomes. Para instalar estas dependencias vamos a utilizar bower, que es un bonito gestor de dependencias.  Vamos a empezar con bootstrap, para instalarlo primero instalamos bower  npm install --save bower , incializamos el fichero de configuración bower.json con el wizard  bower init . Una vez inicializado, instalamos bootstrap  bower install bootstrap --save  y nos aseguramos de que nuestra app tiene acceso a los modulos instalados por bower publicando dicha ruta, para ello añadimos lo siguiente en nuestro app.ts 

Por último, para que al desplegar nuestra app junto con las dependencias de node se instalen también las de bower, añadimos lo siguiente en la sección de “scripts” del fichero package.json:  "postinstall": "./node_modules/bower/bin/bower install" , de esta forma cuando despleguemos nuestro código en un servidor, al hacer npm install también nos instalará estas dependenciasEl resto de módulos necesarios podéis mirarlos en el fichero bower.json del repositorio.

Ya tiene un poco de mejor aspecto, aún asi aun esta fea fea. ¿Qué le falta?. Pues muy sencillo, mis templates tiene lo que necesitan de bower, pero aún así necesita ficheros de nuestro modulo admin-lte. Para que tengan acceso vamos a tener que añadir una linea mas al fichero app.js, junto a la anterior.

Ahora que tiene mejor aspecto y algunos formularios vamos a arreglar las routes, para que podamos verlos. En el fichero users.ts dentro de routes.

A continuación como estrategia de login vamos a utilizar passport. En esta primera parte nos conformaremos con que no de error :-). Vamos a utilizar mongodb para almacenar los datos de login, para instalar mongodb en tu máquina sigue las siguientes instrucciones Install MongoDB. Las distintas estrategias de login las llevaremos a cabo utilizando el paquete passport. Vamos a añadirlos a la lista de dependencias. En primer lugar necesitamos un middleware para las sesiones. Es necesario para utilizar passport.

A continuación inicializamos dentro de nuestra app de express la gestión de sesiones.

Vamos a conectar nuestro proyecto con una base de datos mongodb. Para la configuración de los distintos entornos de base de datos (test, dev, producción) voy a utilizar un fichero de configuración. Creamos un fichero config.ts con el siguiente contenido:

Y en nuestro fichero de app.js inicializamos la base de datos en función del entorno, necesitamos instalar el modulo de mongoose npm install --save mongoose :

Una vez conectado mongoose, vamos a integrar un login local utilizando passport, para ello instalamos el modulo passport-local  npm install --save passport-local. Lo primero que vamos a hacer es crear un modelo para almacenar los datos de las distintas estrategias de login, utilizaremos bcrypt para cifrar las constraseñas  npm install --save bcrypt-nodejs.

Ahora vamos a crear una clase que se encargue de gestionar todas nuestras estrategias de login. Crearemos un fichero passport.ts en la carpeta config con el siguiente contenido.

Y lo incluiremos en el proceso de setup de nuestra app.ts de la siguiente manera.

Una vez hecho esto, tenemos que definir las rutas de nuestra aplicación. Utilizando express.Router(). Las rutas básicas GET son las siguientes: “/”, “/login”, “/signup”, “/logout” y por último “/profile”, esta última se ayuda de una función que nos permite saber si el usuario esta autenticado para darle paso.

Ahora si arrancas la aplicación, deberías ser capaz de darte de alta, logearte y ver tu perfile. En el próximo post seguiré añadiendo funcionalidad a nuestra aplicación web.

Referencias:

Install Python 3 coexisting with Python 2 in Linux

In this post I’m going to explain how to install Python 3 coexisting with Python 2 in Linux (Kubuntu 13.10 in my case). First step is install some dependencies.

After that, download from the website and uncompress the latest version of Python 3 in a folder of your choice.

Inside the uncompressed folder, we’re going to compile and install Python 3 with the following commands:

To make sure about the correct installation execute the following command  /opt/python3.3/bin/python3 and you must get something like that:

Also you should have brand new commands like python3  and python3.3. For the Python 3 modules management we’re going to install pip, but for Python 3 :-). Happily there is a debian package for that, use the following command  sudo apt-get install python3-pip to install it.

Finally we’re going to create a virtual environment of Python 3. There is two ways to do that. The first one, the hard way is specifing the python path that you want to use.

The second one, needs a previous installation of the virutalenv module using pip3  sudo pip3 install virtualenv . After you have installed it, to create Python 2 virtual environment you’ll must use virtualenv-2.7 and to create Python 3 virtual environment virtualenv-3.3. Enter the following command to get your Python 3 virtual environment.

Once you’ve created and set your Python 3 virtual environment, you’ll be able to install new modules using the pip command (inside our Python 3 virtual environment pip command is the same as pip-3.3). Let’s test it by installing the django module with  pip install django. After that, run the Python 3 console and write down the following instructions:

I hope it helps you!

Instalar Python 3 en Linux coexistiendo con Python 2

En este post voy a explicar como instalar Python 3 en Linux coexistiendo con Python 2. El primer paso es instalar las dependencias necesarias.

A continuación vamos a descargar de la web oficial y a descomprimir la ultima versión de Python 3 disponible en una carpeta a nuestra elección.

Nos situamos en dentro de la carpeta descomprimida y nos disponemos a compilar e instalar Python 3.

Finalmente para comprobar que todo ha ido bien ejecutamos  /opt/python3.3/bin/python3 y tenemos que obtener algo parecido a lo siguiente:

Además también tendrás nuevos comandos que podrás utilizar: python3python3.3. Para la gestión de módulos en Python3 vamos a instalar pip, pero para Python 3. Afortunadamente hay una paquete de Debian que nos resuelve esto, utiliza el siguiente comando para instalarlo  sudo apt-get install python3-pip.

Finalmente vamos a crear un entorno virtual de Python 3. Existen dos formas de llevar esto a cabo. La primera, la difícil, es especificando la ruta de la versión de Python que queremos virtualizar.

La segunda, más fácil, necesita que primero instalemos el modulo virtualenv utilizando pip3  sudo pip3 install virtualenv . Una vez este instalado, para crear entornos virtuales de Python 2 tendremos que usar virtualenv-2.7 y para crearlos de Python 3 virtualenv-3.3. Creemos uno de Python 3:

Una vez creado y seleccionado, podremos instalar nuevos modulos usando el comando pippip-3.3. Vamos a probar que todo funciona instalando django pip install django , arrancamos la consola de Python 3 y escribimos el siguiente código:

 

Scraping website using Python, Selenium, Lxml and PhantomJS

In this post I’m going to show a basic example of scraping website using Python with the headless browser PhantomJS. In other words, I’m going to automatize the extraction information process from a website using a browser that doesn’t have/need an user interface.

  • The easiest way to work with Python is using virtual environments with virtualenv. In Linux (Debian in my case) insert the following commands to install it.

    Now, go to a directory of your choice, then you must create and set the new virtual environment with the following commands.
  • First test. We need a couple of dependencies for doing the scraping, selenium and lxml. To do that, type down the following commands  pip install selenium and  pip install lxml inside of our virtual environment. If you have problems installing lxml is because you need some dependencies. So you need to erase the virtual environment that you have just created.

    After that you must install the following dependencies, they’re necessaries for compile the lxml module.

    Once you’ve installed it, create again the virtual environment like we did before, and inside of it execute the installation of lxml. If everything going well you should see something like  Successfully installed lxml . Now we are going to test the following code:

    Save it into a file named “test1.py” and execute it inside the virutal environment venv with  python test1.py, you must get the following exit:
  • Second test. Firstly we are going to install PhantomJS following the instructions in phantomjs.org, we create a folder for it and execute

    Now we’re going to modify the source code of the previous example by changing the instantiation of the browser. Firefox() by PhantomJS(). Beside I’ve specified a dimension for the window browser. If the website have a responsive desing maybe you are interest only in some data for one resolution.

    Save the source code into a file “test2.py” and execute it inside the virtual environment with the following command  python test2.py and you must get the same exit but without open a window browser.

 

References

Web scraping con Python, Selenium, Lxml y PhantomJS

En este post voy a montar un ejemplo básico de web scraping con Python utilizando el navegador headless PhantomJS. En otras palabras voy a automatizar la extracción de información de una pagina web utilizando un navegador  que no tiene/necesita interfaz de usuario.

  • La forma mas cómoda de trabajar con Python es haciendo uso de los entornos virtuales utilizando el virtualenv. Para instalar todo esto en Linux (en mi caso Debian) hacemos:

    A continuación nos vamos a una carpeta a nuestra elección y ahí creamos y seleccionamos el entorno virtual utilizando los siguientes comandos.
  • Primer Test. Para realizar el scraping necesitamos instalar una serie de dependencias por un lado  selenium y por otro lxml. Para ello ejecutamos  pip install selenium y  pip install lxml dentro de nuestro entorno virtual. Si tenéis problemas instalando lxml es porque como a mí, os faltan dependencias. Por lo que tendreís que borrar el virtualenv que acabamos de crear

    Y a continuación instalar las siguientes dependencias necesarias para compilar el modulo lxml.

    Una vez instalado esto, volvéis a crear el virtualenv como hemos hecho antes, y dentro de él ejecutáis de nuevo la instalación de lxml. Si todo ha ido bien deberías ver al final algo como  Successfully installed lxml . Una vez realizado esto vamos a probar el siguiente código:

    Si lo guardamos en un fichero “test1.py” y lo ejecutamos dentro del virtualenv venv con  python test1.py  obtenemos la salida:
  • Segundo Test. Primero vamos a instalar PhantomJS siguiendo las instrucciones de phantomjs.org, en una carpeta a nuestra elección ejecutamos

    Una vez hecho esto nuestro código solo va a cambiar en la instanciación del browser. Además he especificado una una dimensión para la ventana del mismo por si tuviéramos que obtener datos para un tamaño concreto de ventana en el caso de que la información cambiase en función del mismo debido a un diseño responsive.

    Guardamos el código en un fichero “test2.py” y lo ejecutamos dentro de nuestro virtualenv con  python test2.py y obtendremos la misma salida pero no se nos abrirá ningún navegador.

 

Referencias

Setup Cocos2dx environment in Linux for Android (Part 2)

Hi again! If you’ve been able to accomplish the first one, and you’re aim to continue, thi is the second part. In this part, we’re going to run the TestCpp project of Cocos2dx in Android. It’s going to be shorter process than the previous one.

Before we start with the Android part, I want you to try to make a debug against the HelloCpp project in eclipse. In Debian I had a problem. My eclipse said “Error while launching command: gdb –version”. After a while I realized that I hadn’t installed it, http://www.gnu.org/software/gdb/ and it’s necessary for debugging, so sudo apt-get install gdb.

Let’s start with Android. We have to define a couple of enviroment variables inside our eclipse. The first one, COCOS2DX must be defined in Eclipse->Preferences->General->Workspace->Linked Resources. Click in the New button and set the variable to the path of the uncompress folder of Cocos2dx, in my case /home/borja/Programas/cocos2d-x-2.1.4.

The second one, NDK_ROOT, must be defined in Eclipse->Preferences->C/C++->Build->Environment. Click in Add and set the variable value to the path of the uncompress folder of NDK, in my case /home/borja/Programas/android-ndk-r8e.

If you’re compiling the TestCpp project with the last version of Android like me, maybe the NDK shows this error android-ndk-r8e/build/core/add-application.mk:128: Android NDK: WARNING: APP_PLATFORM android-14 is larger than android:minSdkVersion 8 in ./AndroidManifest.xml. You can work around it by modify the file add_application.mk in the line 128, changing  $(call __ndk_warning by $(call __ndk_info.

Now, try to compile the TestCpp project, you should get an output console like this, but a little much longer :-).

Once the building process has finished, launch the app normally in an Android device, and everything should work well.

SC20130717-214505

Thanks for read this. The new group of post that I’m going to write, will be about setup a continuous integration environment in general and for Android particulary.

See you soon!

Instalar el entorno de desarrollo de Cocos2dx en Linux para Android (Parte 2)

Hola de nuevo, si fuiste capaz de acabar la primera parte y aun tienes ánimos para seguir, aquí esta la segunda. En esta vamos a montar la app TestCpp de Cocos2dx para Android. Será mucho mas cortito que el anterior.

Pero primero vamos a hacer un debug del HelloCpp. No por nada, sino porque a mi en mi Debian me falla el debug XD. Recibo el siguiente error: Error while launching command: gdb –version. Y después de un rato me he percatado de que literalmente no tengo instalado, http://www.gnu.org/software/gdb/ y al parecer es necesario para hacer debug XD, tan fácil como:  sudo apt-get install gdb

Para compilar en Android lo primero es definir un par de variables de entorno dentro de nuestro Eclipse. La primera COCOS2DX la definimos en Eclipse->Preferences->General->Workspace->Linked Resources hacemos click en el botón New y apuntamos la variable al directorio raiz donde hemos descomprimido Cocos2dx.

La segunda variable que vamos a definir apunta a ruta donde hemos descomprimido nuestro NDK, NDK_ROOT y la vamos a definir en Eclipse->Preferences->C/C++->Build->Environment. Hacemos click en Add y especificamos como valor la carpeta donde descomprimimos el NDK.

Si como yo estáis compilando el proyecto TestCpp con la última versión de Android, puede que el NDK os de el siguiente error android-ndk-r8e/build/core/add-application.mk:128: Android NDK: WARNING: APP_PLATFORM android-14 is larger than android:minSdkVersion 8 in ./AndroidManifest.xml, este error lo podemos saltar modificando el fichero add-application.mk y en la linea 128 como se indica, cambiando $(call __ndk_warning por $(call __ndk_info.

Hecho esto, trata de compilar el proyecto TestCpp, obtendrás una salida por consola parecida a esta pero mucho mas larga :-).

Una vez terminado el proceso de compilación, arrancamos la app normalmente y todo debería funcionar correctamente.

SC20130717-214505

Gracias por aguantar hasta el final, en la nueva serie de post que voy a escribir, explicaré como montar un sistema de integración continua en general y para Android en particular.

¡Hasta pronto!