Mostrando entradas con la etiqueta linux. Mostrar todas las entradas
Mostrando entradas con la etiqueta linux. Mostrar todas las entradas

miércoles, 13 de julio de 2016

Como crear un servidor web en la red local accesible desde Internet

Hace demasiado tiempo que no escribo nada. Tengo miles de excusas (todas ciertas), pero el caso es que todas ellas se resumen en una: demasiado trabajo. Hoy voy a intentar escribir un artículo sobre como crear un servidor web en la red local accesible desde Internet con Apache2.

Con la mejora de las conexiones que están ofreciendo los operadores de telefonía en los últimos tiempos (banda ancha, fibra óptica, 100/10 MB, 300/30 MB, 300 MB simétricos, ...), cualquiera puede plantearse crear sus propios servicios web sin contratar ningún tipo de hosting. Es decir a coste cero. Bueno cero no porque siempre tendrás que pagar la conexión, pero eso lo ibas a pagar igual, ¿no?

Prerequisitos

Lo primero y más importante es disponer de conexión a Internet de banda ancha en casa. Idealmente fibra óptica simétrica. También es indispensable tener un PC que pueda estar conectado a la red todo el día. El tipo de PC es irrelevante, pero lo idóneo sería que tuviera un sistema operativo de tipo GNU/Linux. Por supuesto todo lo que voy a explicar se puede hacer con Windows, pero a partir de aquí usaré ejemplos para Ubuntu 14.04 que es una distribución de Linux muy popular. También sería muy interesante disponer de una IP estática, aunque no es obligatorio.

Instalar el software requerido

  • Apache2: Es el servidor HTTP más usado en el mundo. Es un programa de código abierto, multiplatafortma (Linux, Macintosh, Windows, ...), que implementa el protocolo HTTP/1.12. Es altamente configurable y permite utilizar multitud de módulos que añaden capacidades al servidor: SSL, Rewrite, PHP, Python, Perl, ...
    $ sudo apt-get install apache2
    $ apache2 -v
    
  • PHP, Python, Perl u otro lenguaje de programación similar. Yo opto por PHP que es muy fácil de usar y muy rápido de aprender, pero cualquier otro es válido. Para usar otros lenguajes como Java se necesitan herramientas diferentes.
    $ sudo apt-get install php5 libapache2-mod-php5
    $ php5 -v
    
  • Una base de datos como MySQL siempre es recomendable, aunque no obligatoria. Depende de los servicios que quieras ofrecer será imprescindible.
    $ sudo apt-get install mysql-server mysql-client php5-mysql
    $ mysql -V
    

Programar el sitio web

Para este paso se necesitan conocimientos de programación. En cualquier caso vamos a crear un sencillo "Hola Mundo" en PHP. Lo primero es editar un fichero de texto en la siguiente ruta:

$ cd /var/www/html/
$ mkdir hello-world
$ cd hello-world
$ gedit index.php

...y escribir el siguiente contenido:

<?php
echo "Hello World!";

Para ver que todo funciona correctamente hay que abrir un navegador e introducir la ruta: http://localhost/hello-world/index.php

Si todo ha ido bien veremos nuestro Hola Mundo en la pantalla del navegador. Si no funciona probablemente haya algún problema con Apache2. Por ejemplo que no se haya iniciado correctamente el servicio:

$ sudo service apache2 start

Acceso desde la red local

En este momento, si tienes otro dispositivo conectado a la misma red local (da igual si es un ordenador, un móvil o un tablet, si es por cable o por wifi), podrás acceder al servidor web del primero usando tu navegador favorito, poniendo la dirección IP del ordenador al que hemos instalado Apache2. Para ello lo primero es averiguar la dirección IP privada del ordenador con el servidor web. Podemos escribir ifconfig en el terminal, pero como sale mucha más información, también podemos usar comandos más complejos, pero que obtienen exactamente la información que necesitamos: La dirección IP:

$ ip route get 8.8.8.8 | head -1 | cut -d' ' -f8
192.168.1.38

En este caso la dirección IP de nuestro servidor es 192.168.1.38. Ojo que esa dirección puede cambiar cada ver que se reinicia el router. Entonces escribimos la siguiente ruta en otro dispositivo (PC, tablet o móvil): http://192.168.1.38/hello-world/index.php

Podría darse el caso de que Apache2 estuviera configurado para rechazar las conexiones desde fuera del localhost. En ese caso obtendríamos un mensaje como el siguiente:

Las causas de ese problema pueden ser muy diversas dependiendo de la versión de Apache2 y proponer soluciones a este problema se escapa del propósito de este artículo. En cualquier caso siempre se le puede preguntar a Google. La solución probablemente pase por editar el archivo /etc/apache2/apache2.conf y eliminar las restricciones de acceso, dejando algo similar a lo siguiente:

<Directory /var/www/>
    AllowOverride None
    Require all granted
</Directory>

Acceso desde Internet

Para acceder a Internet el router usa una IP pública, la misma para toda la red local. Eso quiere decir que todos los dispositivos conectados a la red local usan la misma dirección IP para conectarse a Internet, ya que todos tienen la misma dirección IP pública. Entonces, ¿Como podemos acceder desde el exterior a nuestro servidor web si varios dispositivos comparten la misma IP? La respuesta es que hay que configurar los puertos de red en el router. Es lo que se conoce como abrir puertos.

Apache2 usa por defecto el puerto 80 para el protocolo HTTP, entonces lo que habría que hacer es decirle al router que todas las conexiones que lleguen por el puerto 80 nos las redireccione a la máquina donde tenemos el servidor web que, recordemos, es la 192.168.1.38.

Para poder acceder desde Internet a nuestro servidor web es necesario conocer nuestra IP pública. No la privada que usa nuestro equipo dentro de la red local, sino la pública que es la que usa nuestro router para acceder a Internet y que puede ser fija (siempre la misma) o variable (distinta cada vez que se reinicia el router). Para averiguar nuestra IP pública podemos ir a cualesmiip.com y consultarlo o bien podemos escribir la siguiente instrucción en el terminal:

$ curl ifconfig.me
88.20.46.249

Nuestro servidor web ya es accesible desde Internet pero aun hay varios temas que solucionar:

  1. Cada vez que se reinicie el router la IP privada asignada a nuestro servidor puede cambiar, con lo que éste dejará de ser accesible desde Internet ya que nuestro router seguirá redireccionando las peticiones que lleguen por el puerto 80 a la IP 192.168.1.38 pero a lo mejor ahora nuestro servidor tiene otro. Lo que vamos a hacer es poner una IP privada fija a nuestro servidor.
  2. En segundo lugar abrir el puerto 80 no es lo más inteligente a no ser que queramos hacer una web abierta a todo el mundo. Lo mejor es usar un puerto diferente, dejando el puerto 80 cerrado.
  3. Por último la IP pública de nuestro router también podría cambiar cada vez que se reinicie por lo que no sabríamos que IP poner en el navegador. La única solución a esto es contratar una IP pública estática a nuestro proveedor de Internet.

Asignar una IP privada fija a nuestro servidor web

El router utiliza el protocolo DHCP para asignar las direcciones IP privadas a los distintos dispositivos conectados a la red local. De esta forma cada dispositivo tendrá un IP diferente cada vez que se reinicie el router. Sin embargo es posible asignar de forma sencilla una dirección IP fija (siempre la misma) a un dispositivo determinado. Por desgracia cada dispositivo y cada router tiene su forma particular de hacerlo. Mirando en la configuración de mi router he visto que las direcciones que asigna DHCP para la mi red local son de tipo 192.168.1.x, donde x > 32. Si x=1 es la dirección del router (default gateway), eso quiere decir que tengo libres las direcciones de la 2 <= x <= 32. Yo he elegido la IP 192.168.1.16 sin un motivo concreto.

Para asignar una IP fija en Ubuntu hay que ir a la Configuración del Sistema >>> Red >>> Cableada o Inalámbrica (depende) >>> Opciones... >>> Ajustes IPv4, seleccionar Método manual y rellenar los campos como en la imagen.

Cambiar el puerto de nuestro servicio web

Como hemos dicho el protocolo HTTP suele usar el puerto 80, pero si sólo queremos acceder nosotros a nuestro servicio web podemos configurar Apache2 para que use cualquier puerto en el rango 1-65535. Algunos puertos son usados por otros servicios, como por ejemplo:

  • 20=FTP-data
  • 21=FTP-control
  • 22=SSH
  • 23=Telnet
  • 25=SMTP
  • 80=HTTP
  • 110=POP3
  • 143=IMAP
  • 443=HTTPS-SSL
  • 465=SMTP-SSL
  • 993=IMAP-SSL
  • 995=POP3-SSL
  • 3306=MySQL
  • 8080=Alt-HTTP
  • Ver lista completa

En principio podemos usar cualquier puerto libre. Por ejemplo podemos usar el puerto 8010. Para ello hay que seguir varios pasos:

  1. Decir a Apache2 que tiene que escuchar el puerto 8010. Para ello, editar el archivo /etc/apache2/ports.conf y añadir la línea Listen 8010:
    $ sudo gedit /etc/apache2/ports.conf
    
    Listen 80
    Listen 8010
    <IfModule ssl_module>
        Listen 443
    </IfModule>
    <IfModule mod_gnutls.c>
        Listen 443
    </IfModule>
    
  2. Añadir un virtual host que escuche el puerto 8010. Para ello crear el archivo /etc/apache2/sites-available/001-my-web-server.conf:
    $ sudo gedit /etc/apache2/sites-available/001-my-web-server.conf
    
    <VirtualHost *:8010>
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/html/hello-world
        ErrorLog ${APACHE_LOG_DIR}/error-simple-proxy.log
        CustomLog ${APACHE_LOG_DIR}/access-simple-proxy.log combined
        DirectoryIndex index.php index.html index.htm index.cgi
    </VirtualHost>
    
  3. Activar el nuevo virtual host:
    $ cd /etc/apache2/sites-enabled/
    $ sudo ln -s ../sites-available/001-my-web-server.conf
    
  4. Reiniciar el servicio de Apache2:
    $ sudo service apache2 restart
    

jueves, 28 de noviembre de 2013

Crea tu propio repositorio Git usando Gitolite

Git es un software diseñado por Linus Torvalds, el creador de Linux, que sirve para crear repositorios de código fuente permitiendo realizar el control de versiones de cientos de archivos, soportando múltiples usuarios y mantenimiento distribuido. En los proyectos que usan Git cada usuario dispone de una copia local completa del código fuente (repositorio local), incluyendo el historial de cambios, pero a la hora de fusionar cambios es conveniente tener un repositorio central, accesible por todos los usuarios.

En Internet se pueden encontrar sitios como GitHub o Bitbucket que permiten alojar repositorios de código fuente Git. En concreto GitHub se usa sobre todo para proyectos de software libre, pues es gratuito, aunque también tiene planes de pago para proyectos privativos. Por su parte Bitbucket ofrece cuentas gratuitas de hasta 5 usuarios para todo tipo de proyectos y también dispone de planes de pago para proyectos más grandes.

Tanto Github como Bitbucket ofrecen máxima seguridad y privacidad para alojar allí nuestro código fuente, pero si queremos tener un mayor control sobre donde está realmente nuestro código y quien tiene acceso, podemos crear nuestro propio repositorio central de fuentes Git con Gitolite. En realidad hay otras herramientas tanto gratuitas como de pago para crear y mantener repositorios Git, pero Gitolite es bastante sencilla de usar, además de ser de código abierto y gratuita, al igual que el propio Git.


Instalando y configurando Gitolite

Podríamos definir Gitolite como capa de control de acceso para repositorios Git que permite la administración de múltiples repositorios y usuarios indicando en cada caso quién puede hacer qué y dónde. Gitolite crea un usuario llamado gitolite en el servidor que es el que realiza todas las operaciones sobre el repositorio central. La invocación de acciones (clone, push, pull, etc.) se realiza mediante el protocolo ssh, por lo que será necesario que cada usuario disponga de una clave pública. Vamos a verlo todo en detalle.

Supongamos que tenemos un servidor Linux al que llamaremos SERVIDOR y tres usuarios USUARIO1, USUARIO2 y USUARIO3. Necesitamos tener acceso con permisos de root a la consola del SERVIDOR (puede hacerse vía ssh). Lo primero que haremos será instalar y configurar Git si no está ya instalado.

-- Instalación para Debian, Ubuntu, Mint, etc.
$ sudo apt-get install git git-core

-- Instalación para RedHat, Fedora, CentoOS, etc.
$ sudo yum install git git-core

-- Configuración (todos)
$ git config --global user.name "{usuario}"
$ git config --global user.email "{email}"
$ git config --global core.editor "{editor}"

Hay que sustituir {usuario} por el nombre del usuario, {email} por un email válido y {editor} por tu editor preferido (nano, vim, emacs, etc). Una vez configurado Git procederemos a crear una clave RSA para el servidor, ya que la necesitaremos tras instalar Gitolite:

$ ssh-keygen -t rsa -C "{email}"
$ ssh-add ~/.ssh/id_rsa
$ cp ~/.ssh/id_rsa.pub /tmp/administrador.pub

Hay que sustituir {email} por un email válido (generalmente el mismo que se usó en el paso anterior). También hemos copiado la clave pública id_rsa.pub al directorio /tmp con el nombre administrador.pub. A continuación instalamos Gitolite. Hay varias formas de hacerlo.

Esta página explica todas las formas de instalar Gitolite [en inglés]. Yo he elegido la más sencilla: La instalación por paquetes:

-- Instalación para Debian, Ubuntu, Mint, etc.
$ sudo apt-get install gitolite

-- Instalación para RedHat, Fedora, CentoOS, etc.
$ sudo yum install gitolite

-- Configuración de Gitolite (para todos)
$ sudo su - gitolite
$ gl-setup /tmp/administrador.pub

Al ejecutar esta instrucción Gitolite usa el editor por defecto para mostrarnos el archivo de configuración del programa. En cualquier momento podemos volver a editar este archivo de configuración que se llama .gitolite.rc y está en /var/lib/gitolite/. Es conveniente modificar la configuración por defecto poniendo $GL_WILDREPOS = 1; y $REPO_UMASK = 0027;. Esta página explica todo sobre la configuración de .girolite.rc [en inglés]. Una vez finalizada la edición Gitolite habrá dado permisos de administración a la clave pública que creamos anteriormente. También habrá creado varios archivos y carpetas en el usuario gitolite:

  • ~/.gitolite.rc: Archivo de configuración de gitolite.
  • ~/.gitolite/conf/gitolite.conf: Configuración de repositorios.
  • ~/.gitolite/keydir/: Carpeta de claves públicas de los usuarios.
  • ~/.gitolite/keydir/administrador.pub: Clave pública administrador.
  • ~/projects.list: Lista de proyectos.
  • ~/repositories/: Carpeta de repositorios.

Una vez hecho esto podemos salir del usuario gitolite pues hemos acabado con él:

$ exit

La configuración del programa Gitolite está realizada. Ahora veremos como añadir repositorios y como dar permiso a otros usuarios. Esto se hace desde el usuario cuya clave pública hemos indicado que es el administrador. En este caso un usuario de nuestro propio servidor. Gitolite usa un repositorio Git como método de configuración, lo cual nos sirve a la vez como sistema para comprobar que la instalación de Gitolite fue correcta. Así que lo primero que hay que hacer el clonar el repositorio gitolite-admin.git.

$ git clone gitolite@localhost:gitolite-admin.git

Si todo funciona correctamente se habrá creado una carpeta llamada gitolite-admin en la carpeta home de nuestro usuario del servidor. Seguidamente editaremos el archivo ~/gitolite-admin/conf/gitolite.conf que es el que contiene la configuración de repositorios y usuarios. Esta página explica lo necesario sobre la configuración de gitolite.conf [en inglés]. Para añadir un repositorio o un usuario basta con añadir una entrada a ese archivo siguiendo la notación. Por ejemplo:

@developers = usuario1 usuario2 usuario3
repogitolite-admin
RW+=administrador
repotesting
RW+=@all
repomi-proyecto
RW+=@developers

Ya sólo nos queda crear una clave RSA para cada uno de nuestros usuarios y copiar la clave pública a la carpeta ~/gitolite-admin/keydir/ del servidor, poniendo el mismo nombre que le hemos dado a los usuarios en el archivo de configuración. En nuestro caso usuario1.pub, usuario2.pub y usuario3.pub. Por último subiremos los cambios del proyecto usando el propio Git.

$ cd ~/gitolite-admin/
$ git add .
$ git commit -m '{motivo de la modificación}'
$ git push origin master


Copiando un repositorio desde otro servidor

Puede darse el caso de que tengamos nuestro repositorio central en un servidor y queramos moverlo a otro. Este proceso es en realidad es bastante sencillo de realizar: lo primero es instalar Gitolite en el servidor nuevo, tal como se ha explicado anteriormente. Lo siguiente es entrar en el servidor antiguo y seguir los siguientes pasos:

-- Copiamos el repositorio entero del proyecto antiguo
$ cd /var/lib/gitolite/
$ scp -r repositories/mi-proyecto.git/* gitolite@{servidor}:repositories/mi-proyecto.git/

-- Copiamos .gitolite.rc como .gitolite.rc.bak y salimos
$ scp .gitolite.rc gitolite@{servidor}:.gitolite.rc.bak
$ exit

Debes cambiar {servidor} Por la IP o la URL del servidor nuevo. A continuación debemos entrar en el usuario gitolite del servidor nuevo y hacer lo siguiente:

-- Comprobamos las diferencias entre las dos versiones .gitolite.rc
-- y realizamos los cambios que sean necesarios
$ diff .gitolite.rc .gitolite.rc.bak

-- Reconfiguramos gitolite con los nuevos cambios y salimos
$ gl-setup
$ exit

Ya sólo queda abrir el proyecto gitolite-admin, asegurarnos de que mi-proyecto esté en gitolite.conf, asignar los usuarios al proyecto y subir los cambios. Aquí puedes encontrar más información sobre como mover un repositorio Gitolite a otro servidor.

Bunus track: Si queremos desactivar el servidor antiguo para que los usuarios no puedan enviar cambios basta con editar el archivo .gitolite.rc y poner en la primera línea exit 1;.


Referencias

domingo, 20 de octubre de 2013

Arrancando Ubuntu 13.10 desde Grub Rescue

Tras actualizar uno de nuestros PCs a Ubuntu 13.10 Saucy Salamander he visto que quedaba poco espacio en disco y he decidido eliminar el otro sistema operativo que había instalado (que era Windows 7, pero eso da igual). Tras borrar la partición de Windows he intentado hacer más grande la partición de Linux y ahí han empezado los problemas. Para empezar no se puede tocar la partición en uso, así que he arrancado con el Live CD de Ubuntu y lo he intentado de nuevo con GParted...

La partición sobre la que estaba instalado Ubuntu era una partición lógica dentro de una partición extendida y se encontraba al final del disco. Mal asunto. He intentado mover las particiones al principio para hacerlas más grandes pero GParted no me lo ha permitido, así que he hecho una copia de la partición entera, proceso que ha tardado más una hora. He probado de arrancar Ubuntu desde esa partición y todo ha ido bien así que he vuelto arrancar desde el Live CD, he eliminado la partición extendida y he agrandado al máximo la nueva partición.

Todo ha ido aparentemente bien pero al reiniciar el sistema ha salido un error y ha aparecido Grub Rescue que es una especie de intérprete de comandos de Grub que permite reparar una instalación. Entonces me he puesto a investigar en Internet y he encontrado la solución:

  1. Lo primero que hay que hacer es averiguar cual es el disco duro y la partición sobre la que tienes instalado Ubuntu. Eso se hace con el comando ls:
  2. Grub Rescue> ls
    (hd0) (hd0,msdos1) (hd0,msdos2) (hd1) (hd1,msdos2) (hd2,msdos1)
    Grub Rescue> ls (hd0)/
    Error: Unknown filesystem.
    Grub Rescue> ls (hd0,msdos2)/
    Error: Unknown filesystem.
    Grub Rescue> ls (hd0,msdos1)/
    bin/  boot/  cdrom/  dev/  etc/  home/  lib/  lib64/
    media/  mnt/  opc/  proc/  root/  run/  sbin/  selinux/
    srv/  sys/  tmp/  usr/  var/
    

    Se trata de averiguar que partición tiene instalado nuestro Linux. Para ello hay que mirar una a una el contenido de las particiones ls (hdx,y)/ (ojo con la barra final), hasta dar con la adecuada que en mi caso es la (hd0,msdos1)

  3. Una vez sabemos el nombre interno de la partición a iniciar hay que arrancar Ubuntu desde esa partición. Pare ello basta con ejecutar las siguientes instrucciones, cambiando (hd0,msdos1) por el nombre real de la partición:
  4. Grub Rescue> set root=(hd0,msdos1)
    Grub Rescue> set prefix=(hd0,msdos1)/boot/grub
    Grub Rescue> insmod normal
    Grub Rescue> normal
    
  5. Por último una vez arrancado Ubuntu hay que arreglar Grub para que la siguiente vez funcione correctamente. Para ello hay que abrir un terminar y ejecutar las siguientes instrucciones:
  6. $ sudo update-grub2
    $ sudo grub-install /dev/sda
    

    Hay que elegir bien en que dispositivo instalamos Grub: /dev/sda se corresponde con el primer disco duro (hd0) en Grub Rescue. /dev/sdb sería el segundo disco duro (hd1), /dev/sdc sería (hd2), etc.

Y ya está. Con esto debería funcionar. Puedes encontrar más información aquí, aquí y aquí.