Daniel Peña Perez

Expresiones Regulares explicado para niños

2019-02-12T01:48:00.002-08:00

A todo el mundo le da pereza las expresiones regulares, (a mi al que mas), pero bueno vamos a quitarnos el miedo y voy a poner aqui unos ejemplillos sencillos , que luego van creciendo en complejidad (no mucha) pero para que veamos que no son para tanto si te las cuentan bien desde el principio:

Tenemos una cadena de texto a procesar :

String CHAIN = "abcde %%~~paco123@gmail.comAAbd%%%";

Asi de primeras vemos mucha morralla, vemos un email y simbolos raros...
Vamos a ir testeando expresiones regulares contra esa cadena y asi vamos viendo como podemos ir jugando con ellas y anidandolas

El codigo Java para probarlas es este:

        List<String> regExps = Arrays.asList("\\d", "\\d+", etc.....);
        Pattern p;
        Matcher m;
        List<String> matches = new ArrayList<>();;
        for(String regExp: regExps) {
            matches.clear();
            m = Pattern.compile(regExp).matcher(CHAIN);
            while(m.find()) {
                matches.add(m.group());
            }
            //log.info("{} -> {}", regExp, matches);
            System.out.println(String.format("%s -> %s", regExp, matches));
        }

si nos fijamos en el codigo, cuando una expresion regular se compila y se ejecuta contra una cadena de texto, lo que vamos a ir encontrando son eventos m.find(). Es decir, internamente va a ir revisandose la cadena caracter a caracter y cuando encuentra algo m.find()->return true y el metodo m.group() nos devuelve lo que acaba de encontrar que cumple nuestra expresion regular.
Por lo tanto el procesamiento es orientado a eventos.

Empezamos de las mas sencillas para arriba :

Usamos los parentesis para meter dentro nuetras expressiones regulares. Te encuenta que una expresion regular compleja puede estar compuesta por varias subexpresiones dentro de parentesis.

(\\d) output -> [1, 2, 3]
Esta expresion saca uno por uno todos los digitos
Evalua caracter a caracter y si es un digito salta el find() y nos devuelve un grupo que contiene ese digito. Por lo tanto tenemos en la lista final de ocurrencias 3 entradas, con los numeros 1,2,3.

(\\d+) output -> [123]

Esta expresion es igual va a ir caracter a caracter y si es un numero lo guarda como macheo, pero al tener un "+" le indicamos que si depues de ese digito hay mas digitos que los guarde todos en el mismo grupo, por eso encuentra el 1 y mira el caracter que hay despues , si es otro numero, lo junta con el anterior (12), sigue mirando y encuentra el 3 que tambien machea asi que ya tiene un grupo con 123, como el siguiente caracter es un @ pues da por cerrado el grupo ya que no hay mas coincidencias, entonces la llamada a m.group() devuelve "123". ¿a que explicado asi es mas sencillo?

(\\w) output -> [a, b, c, d, e, p, a, c, o, 1, 2, 3, g, m, a, i, l, c, o, m, A, A, b, d]

Esta es igual que la de los digitos, pero con caracteres alfanumericos y underscore. Como no tiene + va a ir sacando caracter a caracter. Si te fijas ha excluido los espacios y lo simbolos "raros" ~% .

(\\w+) output-> [abcde, paco123, gmail, comAAbd]

Prima hermana de la anterior, pero como lleva el +,cuando encuentra una coincidencia comienza a almacenar en el grupo, y mete en el mismo grupo hasta que no se cumple la condicion. "abcde" se para porque encuentra un espacio asi que no añade mas a a ese grupo y lo devuelve. sigue mirando y lo siguiente es "p" y sigue almacenando "paco123" porque cumple el patron y cuando llega a la @ lo da por cerrado porque no machea.

([a-z]) output-> [a, b, c, d, e, p, a, c, o, g, m, a, i, l, c, o, m, b, d]

Esta especifica un rango de valores, case sensitive. Por eso hace grupos individuales (no tiene el +) con cada caracter que encuentra dentro del rango de las minusculas. si quieres haz la prueba con ([a-m]) y asi veras que excluye las letras posteriores a la m. Mola!, ya puedes ir jugando con algo.

([a-z]+) output-> [abcde, paco, gmail, com, bd]
Esta es la misma que antes, pero agrupa mientras se cumpla el patron.

([a-zA-Z]+) output-> [abcde, paco, gmail, comAAbd]
Esta indica varios grupos de coincidencias, o de la a-z o de la A-Z y ademas me los agrupas si estan seguidos. ¿a que parecia compleja y no era para tanto?

(paco|pedro|com |gmail) output-> [paco, gmail]
Esta especifica un or de un grupò de valores. si es alguno de esos, pues hace un grupo.

(\\d+{3}) output-> [123]
Esta es un poco mas especial, dice que saque los digitos y que los agrupe, pero que los grupos no los haga mas grandes de 3 caracteres. En el ejemplo encuentra el 123 despues de "paco". si la cadena donde busca fuera "paco4567jose12", lo que nos devolveria solo "456" porque son digitos y los agrupa de 3 en 3, ya que luego esta "jose" que no le vale y por ultimo encuentra "12" pero que como no llega a ser un grupo de 3, pues lo descarta.

VAMOS A ANIDARLAS

(paco)(\\d) output-> [paco1]
Esta evalua la primera expresion que encuentra entre parentesis, asi que busca a piñon fijo coincidencias con "paco" y si lo encuentra evalua si despues hay un digito (\\d). En caso de que se cumplan las 2 expresiones nos devuelve un grupo que conteine "paco1".

(paco)(\\d+) -> [paco123]
Prima hermana de la anterior, pero si te fijas al poner el + en la expresion de los digitos, pues sigue pillando digitos hasta que no se cumpla y nos devuelve todo el chorizo junto "paco123".   "Coño, pues tiene sentido, mola".

(paco)^(\\d) output -> []
Esta mola porque usa la negacion "^". Vemos que busca que tenga "paco" y que despues NO contenga un digito, por eso no devuelve ninguna coincidencia, porque despues de "paco" hay un "1". y entonces lo descarta todo.

([a-zA-Z0-9]+) output -> [abcde, paco123, gmail, comAAbd]
Esta busca que el caracter este entre los margenes a-z o A-Z o 0-9, y si hay varias coincidencias seguidas, que las agrupe y me las devuelva como si fuera un "todo".

([a-zA-Z]+)(\\d+) output -> [paco123]
Lo mismo, pero despues de agrupar tiene que mirar si hay digitos y si hay varios digitos seguidos que lo agrupe todo.

([a-zA-Z]+)(\\d+)@ output -> [paco123@]
Lo mismo que la anterior pero ademas que despues aparezca un @. Si te fijas , esta expresion lleva ya 3 condiciones (la de las letras, la de los numeros y que justo despues exista un arroba.

([a-zA-Z]+)(\\d+)@([a-z]+) output -> [paco123@gmail]
Lo mismo, pero que ademas, despue del arroba haya una (o varias) minusculas.

([a-zA-Z]+)(\\d+)@([a-z]+). output -> [paco123@gmail.]
Lo mismo que la anterior y que despues de las minusculas haya un punto "."

([a-zA-Z]+)(\\d+)@([a-z]+).([a-z]{3}) output -> [paco123@gmail.com]
Lo mismo pero que despues del punto haya minusculas y que coga solo 3.

PERO.... SI ACABAMOS DE HACER UNA EXPRESION REGULAR QUE BUSCA EMAILS VALIDOS EN UN CHORIZO DE TEXTO!!!   Y CASI SIN DESPEINARNOS!!

Espero que te haya servido este articulo para entender un poco como funciona y perderle el miedo a las expresiones regulares.

Puedes encontrar estos ejemplos funcionando en mi github:

RegularExpressionsJavaTest

Debuggear maven test en eclipse

2019-01-10T02:40:00.001-08:00

Si estas intentando hacer debug de una tarea de maven test, veras que eclipse no para en los break points.

Es necesario añadir un parametro en el goal de definicion del Debug Maven Configuration.

Asi lo tengo yo y esta funcionando y parando mi mvn test. (el parametro es -DforkMode=never)

Entendiendo Update-Alternatives Unix

2018-12-17T07:55:00.000-08:00

Configurar udpate alternatives, parece complejo pero realmente es una tarea sencilla, ya que realmente lo unico que hace por detras es gestionar link simbolicos.

De esta forma podemos cambiar facilmente de versiones de un programa u otro ejecutable sin tener que hacer una tediosa tarea (como suele seer cambiar la maquina virutal de java, etc..)

Vamos a ver un ejemplo sencillo con distintas versiones de un mismo programa que vamos a llamar danielusV{versionNumber}.sh

vamos a crear la carpeta /tmp/danielus/

>$ mkdir /tmp/danielus
>$ cd /tmp/danielus

y dentro crea 3 ejecutables (imagina que son distintas versiones del programa)

El primer ejecutable:

>$ touch danielusV1.sh
>$ vi danielusV1.sh

Introducimos este contenido:

#!/bin/bash
echo "Welcome to Danielus V1 Program. Your first arg is $1"

>$ chmod +x ./danielusV1.sh

El segundo ejecutable:

>$ cd /tmp/danielus
>$ touch danielusV2.sh
>$ vi danielusV2.sh
    Introducimos este contenido:

    #!/bin/bash
    echo "This is the Danielus V2 Program. Your first arg is $1"

>$ chmod +x ./danielusV2.sh

El tercer ejecutable:

>$ cd /tmp/danielus
>$ touch danielusV3.sh
>$ vi danielusV3.sh
    Introducimos este contenido:

    #!/bin/bash
    echo "Welcome to the Amazing Danielus Software V2 . Your first arg is $1"
>$ chmod +x ./danielusV3.sh

Ahora solo falta darlos de alta como un programa "danielus" generico y añadirle alternativas, de forma que siempre ejecutaremos "danielus", pero segun tengamos configuradas las alternatives
pues correrar uno u otro:

1.Vamos a instalarla version 1,
dpena@ /tmp/danielus () $ sudo update-alternatives --install "/usr/bin/danielus" "danielus" "/tmp/danielus/danielusV1.sh" 1
update-alternatives: utilizando /tmp/danielus/danielusV1.sh para proveer /usr/bin/danielus (danielus) en modo automático
dpena@ /tmp/danielus () $

Si vemos la sintaxis, le estamos diciendo que meta un ejecutable en una de las rutas de nuestro path (/usr/bin siempre esta incluida) y que le ponga de nombre danielus y que realmente lo que se ejecute es /tmp/danielus/danielusV1. El ultimo numero es la prioridad y orden de listado, no tiene mucha importancia, pero cuando querramos editar indicando que se debe ejecutar cuando escribamos "danielus" nos va a pedir ese numero.

Si ahora en cualquier directorio ejecutamos "danielus", (este ejecutable sera encontrado en el PATH ) pero el script real que se ejecuta es donde esta apuntando el link simbolico danielusV1.sh

Vamos a probar:
dpena@ /tmp/danielus () $ danielus hola
Welcome to Danielus V1 Program. Your first arg is hola
dpena@ /tmp/danielus () $

Muy bien pues vamos a dar de alta las otras versiones del ejecutable "danielus", la V2 y la V3:
dpena@ /tmp/danielus () $ sudo update-alternatives --install "/usr/bin/danielus" "danielus" "/tmp/danielus/danielusV2.sh" 2
update-alternatives: utilizando /tmp/danielus/danielusV2.sh para proveer /usr/bin/danielus (danielus) en modo automático
dpena@ /tmp/danielus () $ sudo update-alternatives --install "/usr/bin/danielus" "danielus" "/tmp/danielus/danielusV3.sh" 3
update-alternatives: utilizando /tmp/danielus/danielusV3.sh para proveer /usr/bin/danielus (danielus) en modo automático
dpena@ /tmp/danielus () $

Ya tenemos danielusV1.sh, danielusV2.sh y danielusV3.sh como opciones para configurar el ejecutable global "danielus".

Vamos a jugar con ellos, vamos a configurar que sea el V2, abrimos el menu de esta manera:

>sudo update-alternatives --config danielus
Y se muestra un listado que nos pide que numero queremos que responda cuando se ejecute "danielus"
dpena@ /tmp/danielus () $ sudo update-alternatives --config danielus
Existen 3 opciones para la alternativa danielus (que provee /usr/bin/danielus).

Selección   Ruta                         Prioridad Estado
------------------------------------------------------------
* 0            /tmp/danielus/danielusV3.sh   3         modo automático
1            /tmp/danielus/danielusV1.sh   1         modo manual
2            /tmp/danielus/danielusV2.sh   2         modo manual
3            /tmp/danielus/danielusV3.sh   3         modo manual

Press <enter> to keep the current choice[*], or type selection number:

Escribo "2" y pulso enter:

y ahora pruebo a ejectar "danielus" pasandole un argumento:

dpena@ /tmp/danielus () $ danielus hola
This is the Danielus V2 Program. Your first arg is hola
dpena@ /tmp/danielus () $

como podemos ver, ahora se esta ejecutando la V2, pero la instruccion que ejecuto "danielus" es siempre la misma.

Pues aqui tenemos la magia de los update-alternatives. Una solucion limpia y elegante para manejar distintas versiones de ejecutables, manteniendo nuestro path intacto.

Instalar Supervisor en AWS Ec2

2018-10-09T07:10:00.001-07:00

Supervisor es un software de monitorizacion de procesos locales en el mismo host. Es capaz de capturar la salida del programa y ademas, nos aporta de un acceso web rapido para monitorizar/arrancar/reiniciar y parar cada servicio.

La guia para instalarlo en una instancia Ec2 la teneis en mi gitHub:

https://github.com/danipenaperez/installingSupervisorOnEc2

Instalar Kubernetes en Ubuntu 16.04 (Minikube + VirtualBox)

2018-10-09T02:39:00.002-07:00

Se necesitan 3 elemetos:

VirtualBox instalado en tu maquina
Kubectl (cliente del cluster de kubernetes
Minukube (infraestructura que maneja los contenedores)

Instalando VirtualBox en Ubuntu 16.04 xenial (64 bits)

Descargarlo:

>wget http://download.virtualbox.org/virtualbox/5.1.16/virtualbox-5.1_5.1.16-113841~Ubuntu~xenial_amd64.deb

Instalarlo :

>sudo dpkg -i virtualbox-5.1_5.1.16-113841~Ubuntu~xenial_amd64.deb

Podemos comprobar que se ha instalado con

>vitualbox -h y nos sacara info:

Instalando kubectl

Vamos a instalarlo dependencias desde los repos oficiales:

>sudo apt-get update && sudo apt-get install -y apt-transport-https

instalamos las dependenciasd de apt y las actualizamos

>curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

>echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list

Refrescamos la lista de apt-get

>sudo apt-get update

Y por fin instalamos:

>sudo apt-get install -y kubectl

Instalando MiniKube

Lo descargamos y lo añadimos al path como ejecutable

>curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.30.0/minikube-linux-amd64 && chmod +x minikube && sudo cp minikube /usr/local/bin/ && rm minikube

Comprobamos que esta bien instalado

>minikube version

Arrancar miniKube

Lo arrancamos indicando el nombre del driver de virtualizacion (en mi caso , como instalé VirtualBox pues es asi: --vm-driver=virtualbox , si quisieras usar tu propio host el valor es –vm-driver=none. Por defecto es virtualhost.

>minikube start –vm-driver=virtualbox

Este proceso la primera vez tarda un rato porque tiene que hacer varias descargas.

Trabajando con Kubernetes (Minikube)

Sigue este tutorial y encontraras mas pasos

https://kubernetes.io/docs/setup/minikube/#quickstart

Instalar Confluence en contenedores Docker

2018-10-08T03:47:00.000-07:00

Necesitamos 3 cosas, por un lado un contenedor postgres para tener una bbdd , por otro lado el contenedor con la instacia de confluence y por otro lado crear un bridge (RED9 que nos permita compartir puertos entre los 2 contenedores, de forma que el puerto que exponga el contenedor de postgres sea visible desde el contenedor de confluence.

Creando la red:
Es muy sencillo, basta con crear un identificador de red
>docker network create --driver=bridge local-atlassian-network

Le especificamos que el modo de compartir la red es bridge y le damos el nombre de la red que queramos “local-atlassian-network”. Comprobamos:
>docker network list

Instalando postgres en docker
Vamos a partir de la imagen oficial de la gente de postgres :
https://hub.docker.com/_/postgres/

Importamos la imagen a nuestro local. (por defecto la lastest)
>docker pull postgres

Comprobamos que ha terminado con
>docker image ls -- all
Vemos que sale en el listado

Vamos a arrancarlo , pero indicando que use la red “local-atlassian-network” e indicando la exposicion de puertos:

>docker run -d -p 15432:5432 --net=local-atlassian-network -e POSTGRES_PASSWORD=mysecretpassword --name atlassian-postgres-db postgres
Esto nos arranca un contenedor basado en la imagen de postgres, que le pondra el nombre de atlassian-postgres-db (para poder identificarlo mejor), se arranca como daemon (-d) es decir se queda en segundo plano, expone el puerto interno 5432 para que sea accesible por fuera a traves del 15432 (-p 15432:5432) y que se añada a la red (--net=local-atlassian-networkl).

Vamos a comprobar que podemos entrar, usando un cliente, por ejemplo Dbeaver:

Como vemos, hemos apuntado a localhost y encontramos a traves de docker expuesto a nuestro pc el puerto publico 15432. Vemos que conectamos con el usuario por defecto postgres/mysercretpassword que han sido las credenciales de arranque del contenedor y que conectamos al schema por defecto que existe “postgres”.

Incluso podemos comprobar al inspeccionar la red de docker, que ese contenedor ha sido añadido:
>docker inspect network local-atlassian-network

Vemos que el contenedor pertenece a la red. Tambien hay que tomar en cuenta la ip del Gateway, “172.20.0.1”, este sera la ip sobre la que se abren todos los puertos internos entre los contenedores que comparten la red (lo veremos mas adelante cuando desde el contenedor de confluence intentemos acceder al contenedor de postgres).

Vamos a crear un usuario en la bbdd especifico para manejar la bbdd de confluence:

CREATE ROLE confluenceAdmin LOGIN PASSWORD 'confluenceAdminPass'
SUPERUSER
VALID UNTIL 'infinity';

ahora ya tenemos creado el usuario. Vamos a crear un schema “confluence” con el comando:
CREATE DATABASE confluence
WITH ENCODING='UTF8'
OWNER=confluenceAdmin
CONNECTION LIMIT=-1;

Ya tenemos un usuario y un schema para poder continuar con la instalacion de confluence.

Instalando Contenedor Confluence:
Vamos a instalar la imagen a nuestro local, para luego poder crear contenedores a partir de ella:
https://hub.docker.com/r/atlassian/confluence-server/

Hacemos pull de la imagen:
>docker pull atlassian/confluence-server

Ahora arrancamos un contenedor, tal y como nos indica la web, pero añadiendo que queremos que entre en la red que creamos, añadiendo el parametro –net=local-atlassian-network. Nos queda asi:

>docker run -d -p 8090:8090 -p 8091:8091 --net=local-atlassian-network -v /data/your-confluence-home:/var/atlassian/application-data/confluence --name="confluenceServer" atlassian/confluence-server

Si inspeccionamos la red, vemos que el contenedor ha sido añadido a la red:

ahora, ya esta arrancado Confluence Server, y es accesible a traves del puerto 8090 desde nuestro host. Tambien hemos compartido un directorio de nuestro host al volumen del contenedor, de forma que es accesible directamente. Asi que vamos al wizard de configuracion a traves del navegador:

No selecciono porque no tengo licencia de addons

Ahora nos pide la licencia y nos proporciona un serverID: Asi que vamos al correo que nos mando Atlassian cuando hemos hecho el proceso de compra. Vemos que hay un boton que dige Get License Key:

esto nos lleva a la web. Aqui tenemos la lista de productos contratados.Buscamos el de confluence y podemos obtener la licencia.
En mi caso, como ya tengo la licencia, me sale ahi el valor. En caso de no tenerla todavia hay un boton que dice “obtener licencia” lo pulsas y te pedira el ServerId que tienes en el navegador. Y asi te genera la licencia.
En este tutorial ademas, no voy a usar tampoco la licencia de produccion, ya que acabo de instalar confluence en otro contenedor y mi serverId no va a coincidir, asi que pulso en View Developer License y esa es la licencia que voy a usar:

Siguiente y:

Metemos los datos que ya sabemos, pero acordarse que nuestro contenedor verá el otro contenedor a traves del Gateawy de la red “local-atlassian-network” que tenia la ip 172.20.0.1 (recuerda que para ver la info de la red el comando es
>docker inspect network local-atlassian-network

Recuerda las credenciales confluenceadmin/confluenceAdminPass (Ten en cuenta que el username siempre va en minuscula)

Antes de pulsar en next, vamos a abrir los logs del contenedor de Confluence para ver el progreso y lo que esta pasando.
Para ello ejecutamos
>docker logs -f confluenceServer (que ya según lo abrimos vemos que ya habia logs de cuando arranco el servidor de confluence para mostrarnos el wizard:

Pulsamos en next .

Selecionmo que Confluence maneje sus propios usuarios, ya que no tengo instalado Jira para sincronizarlos.

Creo el usuario administrador:

Y ya hemos terminado:

Start!!

Cucumber acceder al contexto del scenario

2018-10-07T23:35:00.000-07:00

El API de Cucumber nos aporta varios hooks:

@Before uno de esos es(cucumber.api.java.Before) este metodo sera invocado antes de cada scenario. Ademas este metodo nos injecta informacion del contexto del scenario:
@After (cucumber.api.java.Before)

@Before podemos utilizarlo para sacar una referencia al scenario actual. Basta con definir el metodo y dejar la referencia en una variable accesible publica para que pueda ser referenciado:

Este seria un ejemplo de clase:

import cucumber.api.Scenario;
import cucumber.api.java.After;
import cucumber.api.java.Before;

public class Hooks {


    public static Scenario scenario;

    @Before
    public void setUp(Scenario scenario) {
        Hooks.scenario = scenario;
        System.out.println("y el nombre del scenario es "+scenario.getName());
    }

}

Desde cualquier punto podremos usar la variable Hooks.scenario.

Configurar seguridad Apache Server

2018-10-04T01:08:00.000-07:00

Securizando Apache

Este es un pequeño ejemplo de configuracion de seguridad del servidor Apache. Vamos a crear 2 sites en nuestro Apache, uno abierto sin seguridad y otro configurado con seguridad (autenticacion basica).

Creamos los 2 sites , que los vamos a llamar www.site1.com y www.site2.com . Como estos dns no los hemos comprado, vamos a editar nuestro archivo /etc/hosts para que cuando visitemos esas urls nos envie a localhost. Editamos el archivo y metemos estas 2 nuevas lineas al final :

Ahora vamos a crear esos 2 sites en unos directorios accesibles. Yo voy a optar por crear 2 carpetas dentro del directorio /usr/local/apache2/sites (el directorio “sites” lo acabo de generar)

Y dentro creo 2 carpetas llamadas www.site1.com y www.site2.com y dentro de cada una un fichero index.html. De forma que cuando visitemos esas urls se nos sirva el index del sitio:

El contenido del archivo index.html del site1 es solo para pruebas, asi que es muy sencillo:

El index del site2 pues es primo hermano:

Ya tenemos creados 2 sites en nuestro sistema de ficheros, ahora vamos a configurar Apache para que los sirva:

1. Habilitar la configuracion extra para la definicion de virtual host: antiguamente con el httpd.conf lo haciamos todo. Este fichero crecía y crecía y las nuevas versiones de Apache, ofrecen dividir toda la configuracion en distintos archivos y referenciarlos desde el httpd.conf.

Editamos el archivo (en mi caso /usr/local/apache2/conf/httpd.con ) y buscamos la linea

Esa linea por defecto viene comentada, es decir tiene un # al principio. Lo borramos y la dejamos como la foto. Tener en cuenta, que al hacer esto se deshabilita la definicion del famoso “It works” que tiene por defecto el apache cuando lo instalamos. (ya no buscara ese archivo en htdocs/index.html). Cuando haya una peticion, ira a buscar la configuracion al archivo httpd-vhosts.conf.

2 Lo segundo habilitar el modulo rewrite en el fichero de configuracion de apache. Y tambien lo desccomentamos

Salvamos el archivo httpd.conf.

3.Ahora como la configuracion de los sites (virtualhost) la va a sacar del archivo /conf/extra/httpd-vhosts.conf , vamos a ese archivo a editarlo y vamos a hacer basicamente 2 cosas: Definir donde estan los directorios de los 2 sites y luego la definicion de los 2 virtualhost que tendran las reglas de acceso a esos sites. (He quitado las lineas de comentarios y queda un fichero asi )

No tiene nada especial, esta publicados los 2 sites en el puerto 80, pero dependiendo de cual se pida aplicara un directorio u otro. Tambien se ve que he configurado el archivo de log para que lo meta en la carpeta correspondiente del site.

Arrancamos el apache y visitamos http://www.site1.com y http://www.site2.com y vemos que cada uno nos sirve su pagina de inicio.

Ya tenemos esto funcionando.

3.Ahora vamos a securizar el site2 con autenticacion Basic.

Para ello necesitamos crear un fichero de credenciales que contenga la info de los usuarios autorizados. Creamos una carpeta dentro de /www.site2.com/ llamada “auth” y dentro de ella ejecutamos la utilidad de apache para generacion de archivos de contraseñas:

>/usr/local/apache2/sites/www.site2.com/auth# htpasswd -c ./auth_users user1

El -c le dice que tiene que crear un fichero llamado auth_users

El argumento del final “user1” es el nomrbe del usuario que vamos a dar de alta.

Al ejecutar nos preguntara por el password, lo metemos y comprobamos que se ha creado el archivo.

4.Ahora solo falta editar el virtualhost del site2 para decirle que use la autenticacion basica y donde tiene el fichero de usuarios permitidos, lo dejamos asi :

Solo hemos añadido la etiqueta <Location /> y dentro las reglas de seguridad y la ruta al archivo.

Si reiniciamos apache y visitamos www.site1.com podemos seguir entrando sin problemas.

Si visitamos www.site2.com vemos que nos pide usuario/pass para poder acceder.

Securizar un sitio, basado en un fichero de acceso casi nunca cumple nuestras necesidades, ya que a nuestro site suelen acceder miles de usuarios que tenemos en una bbdd. Apache es muy flexible en este sentido y el modulo mod_proxy puede encargarse de toda esta funcionalidad. Para mas documentacion visitar la pagina oficinal de apache mod_proxy

https://httpd.apache.org/docs/2.4/mod/mod_proxy.html