Diferència entre revisions de la pàgina «FIVAN - Manual técnico»
(15 revisions intermèdies per 2 usuaris que no es mostren) | |||
Línia 145: | Línia 145: | ||
sudo apt install suricata | sudo apt install suricata | ||
− | ==== | + | ====Configuración de Suricata==== |
Vamos a proceder con la configuración de suricata para detectar ataques de injecion de SQL y ataques DDos por ICMP y TCP. | Vamos a proceder con la configuración de suricata para detectar ataques de injecion de SQL y ataques DDos por ICMP y TCP. | ||
Línia 158: | Línia 158: | ||
<pre> | <pre> | ||
+ | # Detencion de ataques MySQL | ||
+ | alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"SQL Injection - Comments and text delimiter"; flow:to_server;pcre:"/(\%27)|(\')|(\-\-)|(%23)|(#)/i"; sid:1000001; rev:1;) | ||
+ | alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"SQL Injection - SQL key word"; flow:to_server;pcre:"/((\%3D)|(=)).*((\%6F)|o|(\%4F))((\%72)|r|(\%52))/i"; sid:1000002; rev:1;) | ||
+ | alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"SQL Injection - SQL key word"; flow:to_server;pcre:"/((\%3D)|(=)).*((\%61)|a|(\%41))((\%6E)|n|(\%4E))((\%64)|d|(\%44))/i"; sid:1000005; rev:1;) | ||
+ | |||
# Deteccion de ataques DDos | # Deteccion de ataques DDos | ||
− | alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"Possible TCP DoS"; flow: to_server; flags: S; detection_filter: track by_src, | + | alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"Possible TCP DoS"; flow: to_server; flags: S; detection_filter: track by_src, count 50, seconds 1; sid:1000003;rev:1;) |
− | alert ICMP any any -> $HOME_NET any (msg:"Possible ICMP DoS"; detection_filter: track by_src, count 1, seconds 1; sid:1000004 | + | alert ICMP any any -> $HOME_NET any (msg:"Possible ICMP DoS"; detection_filter: track by_src, count 1, seconds 1; sid:1000004; rev:1; ) |
− | |||
− | |||
− | |||
− | |||
− | |||
</pre> | </pre> | ||
Una vez que tenemos las reglas configuradas vamos a configurar el archivo de configuración de suricata: | Una vez que tenemos las reglas configuradas vamos a configurar el archivo de configuración de suricata: | ||
− | sudo nano /etc/suricata/suricata. | + | sudo nano /etc/suricata/suricata.yaml |
− | Nos dirigimos a la sección de rule-files y agregamos el nombre del fichero que hemos creado anteriormente. | + | Nos dirigimos a la sección de '''rule-files''' y agregamos el nombre del fichero que hemos creado anteriormente. |
rule-files: | rule-files: | ||
Línia 309: | Línia 309: | ||
Ahora podremos ver dentro de '''/home/pi/html''' en el cliente como tenemos la carpeta compartida y podremos meter los archivos. | Ahora podremos ver dentro de '''/home/pi/html''' en el cliente como tenemos la carpeta compartida y podremos meter los archivos. | ||
− | Por último, antes de acabar de configurar WordPress, tendremos que'''desplegar el docker''' que falta con el mismo comando que en el punto anterior. Con esto conseguimos trabajar con los mismos ficheros en los dos dockers y tenerlo todo sincronizado. | + | Por último, antes de acabar de configurar WordPress, tendremos que '''desplegar el docker''' que falta con el mismo comando que en el punto anterior. Con esto conseguimos trabajar con los mismos ficheros en los dos dockers y tenerlo todo sincronizado. |
===WordPress=== | ===WordPress=== | ||
Línia 422: | Línia 422: | ||
path = /home/pi/html/ | path = /home/pi/html/ | ||
public = yes | public = yes | ||
− | + | writeable = yes | |
comment = smb share | comment = smb share | ||
guest ok = yes | guest ok = yes | ||
Línia 456: | Línia 456: | ||
sudo service smbd restart | sudo service smbd restart | ||
− | === | + | ===Filebeat=== |
− | + | Filebeat es un cargador de datos de registro para archivos locales. Instalado como un agente en sus servidores, Filebeat supervisa los directorios de registro o archivos de registro específicos, las colas de los archivos, y los reenvía a Elasticsearch o Logstash para la indexación. | |
− | |||
====Instalación y compilación==== | ====Instalación y compilación==== | ||
− | Elastic Stack no ofrece soporte para la arquitecta armhf así | + | Elastic Stack no ofrece soporte para la arquitecta '''armhf''' así que tendremos que compilarlo como explicamos a continuación. |
'''Dependencias''' | '''Dependencias''' | ||
Línia 472: | Línia 471: | ||
Pip se puede usar para instalar virtualenv: | Pip se puede usar para instalar virtualenv: | ||
− | user@raspberrypi:~ $ sudo pip install virtualenv | + | user@raspberrypi:~ $ sudo pip install virtualenv |
'''Go''' | '''Go''' | ||
Línia 481: | Línia 480: | ||
<pre> | <pre> | ||
− | + | pi@raspberrypi:~ $ wget https://redirector.gvt1.com/edgedl/go/go1.9.2.linux-armv6l.tar.gz | |
− | + | pi@raspberrypi:~ $ sudo tar -C /usr/local -xzf go1.9.2.linux-armv6l.tar.gz | |
− | + | pi@raspberrypi:~ $ export PATH=$PATH:/usr/local/go/bin | |
− | + | pi@raspberrypi:~ $ go version | |
go version go1.9.2 linux/arm | go version go1.9.2 linux/arm | ||
</pre> | </pre> | ||
Línia 495: | Línia 494: | ||
<pre> | <pre> | ||
− | + | pi@raspberrypi:~ $ export GOPATH=$HOME/go | |
− | + | pi@raspberrypi:~ $ mkdir go | |
− | + | pi@raspberrypi:~ $ mkdir -p ${GOPATH}/src/github.com/elastic | |
− | + | pi@raspberrypi:~ $ cd ${GOPATH}/src/github.com/elastic | |
− | + | pi@raspberrypi:~/go/src/github.com/elastic $ | |
</pre> | </pre> | ||
Línia 505: | Línia 504: | ||
<pre> | <pre> | ||
− | + | pi@raspberrypi:~/go/src/github.com/elastic $ git clone https://github.com/elastic/beats.git | |
− | + | pi@raspberrypi:~/go/src/github.com/elastic $ cd beats/ | |
− | + | pi@raspberrypi:~/go/src/github.com/elastic/beats $ git checkout 1122568 | |
− | + | pi@raspberrypi:~/go/src/github.com/elastic/beats $ cd filebeat/ | |
− | + | pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ make | |
</pre> | </pre> | ||
go build -i | go build -i | ||
user@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ make update | user@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ make update | ||
+ | |||
+ | Nos deberia de dar un resulta similar al siguiente | ||
+ | |||
<pre> | <pre> | ||
New python executable in /home/user/go/src/github.com/elastic/beats/filebeat/build/python-env/bin/python | New python executable in /home/user/go/src/github.com/elastic/beats/filebeat/build/python-env/bin/python | ||
Línia 527: | Línia 529: | ||
-- The index pattern was created under /home/user/go/src/github.com/elastic/beats/filebeat/_meta/kibana/default/index-pattern/filebeat.json | -- The index pattern was created under /home/user/go/src/github.com/elastic/beats/filebeat/_meta/kibana/default/index-pattern/filebeat.json | ||
</pre> | </pre> | ||
+ | |||
+ | Dos elementos a tener en cuenta como parte de la construcción de Filebeat: | ||
+ | |||
+ | <ul> | ||
+ | <li> | ||
+ | El comando de pago de git es importante. Cada versión del plugin beats está diseñada para funcionar con la misma versión de Logstash y Elasticsearch. El código de hash apropiado para la versión de destino se puede encontrar en el sitio de publicación de elástico / tiempos . Cuando ejecute filbeat por primera vez (a continuación), asegúrese de que la versión compilada sea la esperada. | ||
+ | </li> | ||
+ | <li> | ||
+ | Se supone que compilar cosas con go toma una gran cantidad de memoria. Algunas de las guías mencionaron la necesidad de aumentar la cantidad predeterminada de archivo de intercambio disponible. Al completar los pasos anteriores en una Raspberry Pi 3 esto no fue requerido. | ||
+ | </li> | ||
+ | </ul> | ||
+ | |||
+ | '''Activar de módulos''' | ||
+ | |||
+ | explicacion de que son los modulos y activarlos el modulo de apache2 y filebeat | ||
+ | |||
+ | Antes de seguir estos pasos, verifique que Elasticsearch y Kibana se estén ejecutando y que Elasticsearch esté listo para recibir datos de Filebeat. | ||
+ | |||
+ | Habilitar el módulo: | ||
+ | |||
+ | pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $sudo ./filebeat modules enable apache2 | ||
+ | pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $sudo ./filebeat modules enable mysql | ||
+ | |||
+ | Para ver una lista de módulos habilitados y deshabilitados, ejecute: | ||
+ | |||
+ | pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ sudo ./filebeat modules list | ||
+ | |||
+ | Configurar el entorno inicial: | ||
+ | |||
+ | pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ sudo ./filebeat setup -e | ||
+ | |||
+ | Ejecuta Filebeat: | ||
+ | |||
+ | pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ sudo ./ filebeat -e | ||
+ | |||
+ | Suponiendo que todo vaya bien, ahora debería tener un nuevo ejecutable llamado Filebeat. Ahora se puede ejecutar utilizando los indicadores de línea de comando -e (enviar salida a la consola) y -v (datos de nivel de información de registro) para confirmar que funciona bien. | ||
+ | |||
+ | pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $sudo ./ filebeat -e | ||
==Servidor en AWS== | ==Servidor en AWS== | ||
Línia 605: | Línia 645: | ||
Para empezar a usar kibana tendremos que ir a nuestro navegador e introducir la URL. [http://localhost:5601 http://localhost:5601] | Para empezar a usar kibana tendremos que ir a nuestro navegador e introducir la URL. [http://localhost:5601 http://localhost:5601] | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− |
Revisió de 15:45, 28 maig 2018
Esquema
Para realizar este proyecto, utilizaremos la forma más simple de equilibrar la carga del tráfico de red a varios servidores es usar el balanceador de carga de capa 4 (capa de transporte). De esta manera reenviará el tráfico del usuario en función del rango de IP y el puerto.
El usuario accede al balanceador de carga, que reenvía la solicitud del usuario al grupo de servidores back-end web-backend. Cualquiera que sea el servidor de back-end seleccionado, responderá directamente a la solicitud del usuario. En general, todos los servidores en el servidor web deben servir contenido idéntico; de lo contrario, el usuario podría recibir contenido incoherente. Ambos servidores web se conectan al mismo servidor de base de datos.
Hardware
Antes de empezar indicaremos que hardware hemos utilizado para llevarlo a cabo.
4 Raspberry Pi 3 | 4 Micro SD 16GB | 1 Hard Drive 500GB |
Instalación OS
Una vez tenemos montadas las Raspberry, lo primero que debemos hacer para trabajar con ellas es instalar un sistema operativo en cada una de ellas. En nuestro caso hemos utilizado Raspbian Stretch Lite. Raspbian Stretch Lite es un sistema operativo Debian sin interfaz gráfica. La ventaja que ofrece no tener interfaz, es que estas máquinas, al tener 1GB de RAM, podemos aprovechar más espacio de memoria que si tuviésemos un sistema operativo con interfaz y así poder evitarnos posibles sobrecargas.
Empezaremos descargando la imagen. (Download Raspbian for Raspberry Pi)
Al mismo tiempo tendremos que descargar también Etcher. Este programa nos permite grabar una imagen en un sistema de almacenamiento para utilizarlo como arranque y cargar así nuestro OS. (Download Etcher)
Una vez tengamos todo en nuestro sistema, empezaremos el proceso para poder trabajar en la Raspberry:
- Abriremos Etcher e introduciremos la microSD en nuestro equipo.
- Agregaremos la iso y le daremos a Flash para empezar el proceso.
- Una vez finalizado, extraeremos la microSD y la introduciremos en nuestra Raspberry para empezar a trabajar en nuestro sistema operativo Raspbian.
Para acceder, utilizamos el usuario pi que viene por defecto con password raspberry.
Por defecto, la distribución de teclado nos vendrá en Inglés. Para cambiarla deberemos usar la siguiente comanda y configurar la distribución de nuestro teclado en Español.
sudo dpkg-reconfigure keyboard-configuration
Habilitar servicio SSH
SSH (Secure SHell, en español: intérprete de órdenes seguro) es el nombre de un protocolo y del programa que lo implementa, y sirve para acceder servidores privados a través de una puerta trasera o backdoor. Permite manejar por completo el servidor mediante un intérprete de comandos. Se le asigna por defecto el puerto TCP 22.
El servicio SSH viene instalado ya por defecto, por lo tanto solo deberemos activarlo.
Activamos servicio SSH:
sudo systemctl enable ssh
Una vez activado lo iniciamos:
sudo service ssh start
Conexión cliente-servidor
Una vez habilitado el servicio, para conectarnos a nuestra Raspberry utilizaremos la siguiente comanda:
ssh -l pi direccion_ip
Load Balancer
Ahora nos centraremos en la implementación específica de cada Raspberry. Empezaremos con la que se encarga del balanceo de carga (en inglés, Load Balancer) y la alta disponibilidad.
Para ello, utilizaremos el software HAProxy, ya que incorpora las utilidades nombras anteriormente y necesarias para nuestro proyecto. (Más información clic aquí)
HAProxy
HAProxy es una solución popular de software de fuente abierta TCP / HTTP Load Balancer y proxy que se puede ejecutar en Linux, Solaris y FreeBSD. Su uso más común es mejorar el rendimiento y la confiabilidad de un entorno de servidor mediante la distribución de la carga de trabajo en varios servidores (por ejemplo, web, aplicación, base de datos).
Instalación
Para instalar HAProxy, utilizaremos el siguiente comando:
sudo apt update sudo apt install haproxy
Configuración
Empezaremos a configurar HAProxy para conseguir tener el balanceo de carga y la alta disponibilidad. Para ello debemos ir al archivo /etc/haproxy/haproxy.cfg y modificar las siguientes líneas.
sudo nano /etc/haproxy/haproxy.cfg
frontend http_front bind *:80 stats uri /haproxy?stats default_backend http_back backend http_back balance roundrobin server <server1 name> <private IP 1>:80 check server <server2 name> <private IP 2>:80 check
Sesiones
Algunas aplicaciones requieren que un usuario continúe conectándose al mismo servidor back-end. Esta persistencia se logra a través de sesiones adhesivas. Cambiaremos algunos parámetros de nuestro archivo para conseguir que un usuario no pierda la sesión. Lo modificamos del siguiente modo:
frontend http_front bind *:80 stats uri /haproxy?stats default_backend http_back
backend http_back balance leastconn cookie JSESSIONID prefix nocache server <server1 name> <private IP 1>:80 check cookie <server1 name> server <server2 name> <private IP 2>:80 check cookie <server2 name>
Los parámetros más utilizados para el balancear la carga son los siguientes:
roundrobin | Round Robin selecciona servidores por turnos, es decir, va alternando un servidor con otro repartiendo uno a uno cada conexión. |
leastconn | Selecciona el servidor con la menor cantidad de conexiones: se recomienda para sesiones más largas. Los servidores en el mismo back-end también se rotan de manera round-robin. |
source | Esto selecciona qué servidor usar basado en un hash de la IP de origen, es decir, la dirección IP de su usuario. Este es un método para garantizar que un usuario se conecte al mismo servidor. |
Suricata
Suricata es un motor de detección de amenazas de red gratuito, maduro, sólido y de código abierto. Este inspecciona el tráfico de la red utilizando reglas potentes y extensas y lenguaje de firma, y tiene un poderoso soporte de secuencias de comandos Lua para la detección de amenazas complejas.
Instalación de suricata
Antes de instalar suricata necesitamos instalar las dependencias.
sudo apt-get -y install libpcre3 libpcre3-dbg libpcre3-dev \ build-essential autoconf automake libtool libpcap-dev libnet1-dev \ libyaml-0-2 libyaml-dev zlib1g zlib1g-dev libmagic-dev libcap-ng-dev \ libjansson-dev pkg-config
Ahora que ya tenemos las dependencias, comenzaremos a instalar suricata
sudo apt install suricata
Configuración de Suricata
Vamos a proceder con la configuración de suricata para detectar ataques de injecion de SQL y ataques DDos por ICMP y TCP.
Para ello tenemos que crear un archivo en /etc/suricata/rules/DDos_SQL.rules.
sudo touch /etc/suricata/rules/DDos_SQL.rules
Una vez que tenemos el archivo tenemos que entrar para editarlo:
sudo nano /etc/suricata/rules/DDos_SQL.rules
# Detencion de ataques MySQL alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"SQL Injection - Comments and text delimiter"; flow:to_server;pcre:"/(\%27)|(\')|(\-\-)|(%23)|(#)/i"; sid:1000001; rev:1;) alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"SQL Injection - SQL key word"; flow:to_server;pcre:"/((\%3D)|(=)).*((\%6F)|o|(\%4F))((\%72)|r|(\%52))/i"; sid:1000002; rev:1;) alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"SQL Injection - SQL key word"; flow:to_server;pcre:"/((\%3D)|(=)).*((\%61)|a|(\%41))((\%6E)|n|(\%4E))((\%64)|d|(\%44))/i"; sid:1000005; rev:1;) # Deteccion de ataques DDos alert tcp any any -> $HOME_NET $HTTP_PORTS (msg:"Possible TCP DoS"; flow: to_server; flags: S; detection_filter: track by_src, count 50, seconds 1; sid:1000003;rev:1;) alert ICMP any any -> $HOME_NET any (msg:"Possible ICMP DoS"; detection_filter: track by_src, count 1, seconds 1; sid:1000004; rev:1; )
Una vez que tenemos las reglas configuradas vamos a configurar el archivo de configuración de suricata:
sudo nano /etc/suricata/suricata.yaml
Nos dirigimos a la sección de rule-files y agregamos el nombre del fichero que hemos creado anteriormente.
rule-files: - DDos_SQL.rules - botcc.rules - ciarmy.rules - compromised.rules - drop.rules - dshield.rules
Aprovechamos que estamos dentro del fichero de configuración y vamos a la sección de address-groups e indicamos cual es el rango de IPs de nuestra red interna (HOME_NET):
vars: # Holds the address group vars that would be passed in a Signature. # These would be retrieved during the Signature address parsing stage. address-groups: HOME_NET: "[192.168.1.0/24]" EXTERNAL_NET: "!$HOME_NET" HTTP_SERVERS: "$HOME_NET"
Web-Backend
Esta parte se referirá a toda la instalación y configuración que se haga sobre las dos Raspberry. Contendrán en ellas la web de la tienda online. Esta tienda será implementada en Wordpress dentro de un docker, conectada a una base de datos externa que ya comentaremos más adelante. Elegimos hacerlo en docker ya que la infraestructura es más sencilla y básicamente tiene un despliegue rápido. La gran ventaja es que si esto en algún momento falla, podremos volver a levantar con facilidad de nuevo todo nuestro servidor de una manera rápida y sencilla.
Docker
La idea detrás de Docker es crear contenedores ligeros y portables para las aplicaciones software que puedan ejecutarse en cualquier máquina con Docker instalado, independientemente del sistema operativo que la máquina tenga por debajo, facilitando así también los despliegues.
Instalación Docker CE
Podemos instalar Docker CE de diferentes formas, según sus necesidades:
- La mayoría de los usuarios configuran repositorios de Docker e instalan desde ellos, para facilitar la instalación y las tareas de actualización. Este es el enfoque recomendado.
- Algunos usuarios descargan el paquete DEB, lo instalan manualmente y administran las actualizaciones de forma completamente manual. Esto es útil en situaciones como la instalación de Docker en sistemas de espacio aéreo sin acceso a Internet.
- En entornos de prueba y desarrollo, algunos usuarios optan por utilizar scripts automatizados de conveniencia para instalar Docker. Este es actualmente el único enfoque para Raspbian.
A pesar de las distintas formas que hay para instalar el docker-ce, nosotros usaremos los repositorios, ya es que es la más recomendada.
INSTALAR USANDO EL REPOSITORIO
Antes de instalar Docker CE por primera vez en una máquina host nueva, debe configurar el repositorio Docker. Después, puede instalar y actualizar Docker desde el repositorio.
Configurar el repositorio
- Actualice el aptíndice del paquete: sudo apt-get update
- Instalar paquetes para permitir el aptuso de un repositorio a través de HTTPS: sudo apt-get install \ apt-transport-https \ ca-certificates \ curl \ gnupg2 \ software-properties-common
- Agregue la clave GPG oficial de Docker: curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add - Verifique que ahora tiene la clave con la huella digital 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88, buscando los últimos 8 caracteres de la huella digital. sudo apt-key fingerprint 0EBFCD88
- Use el siguiente comando para configurar el repositorio estable . Siempre necesita el repositorio estable , incluso si desea instalar compilaciones desde el borde o repositorios de prueba . Para agregar el repositorio de borde o prueba , agregue la palabra edgeo test(o ambos) después de la palabra stableen los comandos a continuación. echo "deb [arch=armhf] https://download.docker.com/linux/debian \ $(lsb_release -cs) stable" | \ sudo tee /etc/apt/sources.list.d/docker.list
pub 4096R/0EBFCD88 2017-02-22 Key fingerprint = 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88 uid Docker Release (CE deb) <docker@docker.com> sub 4096R/F273FCD8 2017-02-22
Instalar docker ce
- Actualiza el aptíndice del paquete. sudo apt-get update
- Instale la última versión de Docker CE, o vaya al siguiente paso para instalar una versión específica: sudo apt-get install docker-ce
- Verifique que Docker CE esté instalado correctamente ejecutando la hello-world imagen. sudo docker run hello-world
Despliegue WordPress
Ahora ya solo queda levantar nuestro contenedor. Para ello nos descargaremos la imagen de WordPress para que sea compatible con arquitectura Raspberry Pi. Utilizaremos el comando docker pull.
docker pull arm32v7/wordpress
Ahora desplegaremos nuestro contenedor con docker run. Abrimos los puertos 80 y 3306 para la conexión a nuestra base de datos y para poder ver nuestro WordPress a través de un servidor web. También con el parámetro -v crearemos volúmenes, es imporatante ya que esto nos permitirán trabajar con nuestro contenedor de docker pero teniendo siempre los archivos en local para si en algún momento falla, poder borrar el docker y volverlo a levantar con facilidad y sin perder nada.
docker run -it -p 3306:3306 -p 80:80 -v ~/html:/var/www/html -v ~/logs:/var/log/apache2 -d arm32v7/wordpress
Samba Client
Antes de acabar de configurar WordPress, cuando tengamos los archivos extraídos de un docker a local (con el parámetro -v en el docker run), necesitamos que nuestros contenedores carguen sus archivos a partir de una carpeta compartida para que tengamos sincronizada la información y los dos servidores actúen como uno. Para ello, antes de seguir esta parte del tutorial, deberemos instalar un servidor samba. (Clic aquí para ver)
Una vez tengamos todo configurado en el servidor, montaremos un disco que contendrá la carpeta compartida de nuestro servidor.
Instalación Samba Client
Para empezar, instalaremos samba client.
sudo apt install smbclient
Configuración fichero fstab
Una vez instalado, montaremos la carpeta en nuestro servidor y copiaremos los archivos extraídos del docker a esta carpeta. Para ello, montaremos primero la carpeta en el fichero /etc/fstab de la siguiente manera.
sudo nano /etc/fstab
Creamos la carpeta donde queramos montar para compartir.
sudo mkdir /home/pi/html
Por último añadiremos la última línea a nuestro fichero.
proc /proc proc defaults 0 0 PARTUUID=548eb786-01 /boot vfat defaults 0 2 PARTUUID=548eb786-02 / ext4 defaults,noatime 0 1 # a swapfile is not a swap partition, no line here # use dphys-swapfile swap[on|off] for that //ip_servidor/wordpress /home/pi/html cifs rw,user,username=pi,password=raspberry 0 0
Ahora podremos ver dentro de /home/pi/html en el cliente como tenemos la carpeta compartida y podremos meter los archivos.
Por último, antes de acabar de configurar WordPress, tendremos que desplegar el docker que falta con el mismo comando que en el punto anterior. Con esto conseguimos trabajar con los mismos ficheros en los dos dockers y tenerlo todo sincronizado.
WordPress
Una vez llegados a este punto, WordPress nos permite crear nuestra tienda de manera sencilla a través de sus herramientas que ya analizaremos más adelante. Ahora terminaremos de configurarlo a través de la interfaz gráfica.
Configuración por interfaz
Para acabar de configurar WordPress necesitaremos introducir la IP de nuestra Raspberry en la URL del navegador y seguir los pasos.
http://direccion_ip/wordpress
-
Selección lenguaje
Ahora seleccionaremos el lenguaje de nuestro WordPress y continuamos.
-
Connectar con database
Ahora necesitaremos conectarlo con nuestra base de datos creada previamente. (Haz clic aquí para ver como crear la base de datos)
-
Empezar
Ahora empezaremos a instalar WordPress y sus archivos. Clicaremos en Ejecutar la instalación.
-
Información WordPress
Ahora le daremos un titulo a nuestra página de WordPress y unos datos de usuario para poder acceder. Al finalizar instalamos WordPress.
-
Login
Una vez finalizada la instalación ya podremos acceder con nuestro usuario creado anteriormente y empezar a utilizar WordPress.
Database
Esta Raspberry contendrá un servidor MySQL con un cliente para poder introducir la base de datos de wordpress y crear usuarios. Esta base de datos estará conectada externamente al docker de WordPress.
MySQL Server
MySQL es la base de datos de código abierto más popular del mundo. Con su rendimiento comprobado, fiabilidad y facilidad de uso, MySQL se ha convertido en la principal opción de base de datos para aplicaciones basadas en web.
Instalación MySQL Server
Ahora comenzaremos a instalar el servicio MySQL. Será tan sencillo como introducir la siguiente comanda.
sudo apt install mysql-server
Configuración fichero
Para conectarnos desde otra maquina debemos tener el puerto 3306 por defecto abierto. Debemos permitir conexiones externas, para ello iremos al archivo /etc/mysql/mariadb.conf.d/50-server.cnf y modificaremos el bind-address.
sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf
Modificaremos la siguiente linea e introduciremos la IP de nuestra red interna para poder conectarnos solo los equipos que están en esta red.
# Instead of skip-networking the default is now to listen only on # localhost which is more compatible and is not less secure. bind-address = 0.0.0.0
Instalación cliente MySQL
Para conectarnos a nuestro servidor necesitaremos un cliente, para ello instalaremos el cliente de MySQL y así poder realizar conexiones para crear la base de datos y los usuarios.
sudo apt install mysql-client
Acceso base de datos
Una vez instalado cliente y servidor (docker), necesitaremos acceder a MySQL a través del cliente. Para ello escribimos el siguiente comando con el usuario root y sin contraseña por defecto.
mysql -u root -p
Ahora ya podremos trabajar dentro de nuestro servidor.
Creación base de datos y usuario
Una vez hemos accedido, ya podremos empezar a crear base de datos y agregar usuario/s en ella. Aquí veremos un ejemplo de lo que nosotros hemos creado para nuestro WordPress.
Empezaremos creando le nombre de la base de datos. Nosotros no nos hemos complicado mucho y le hemos puesto wordpress.
mysql> CREATE DATABASE wordpress DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;
Una vez creada la base de datos, crearemos un usuario con una contraseña (se recomienda utilizar una segura) y le daremos privilegios.
mysql> GRANT ALL ON wordpress.* TO 'user'@'%' IDENTIFIED BY 'password';
Ahora deberemos incluir lo siguiente para que se apliquen los cambios.
mysql> FLUSH PRIVILEGES;
Si ya hemos terminado y deseamos salir:
mysql> exit;
Samba Server
Samba permite a PCs que utilizan Linux, conectarse a carpetas compartidas en PCs con Windows y compartir carpetas como si de un sistema Windows se tratara. Gracias a samba, en una red podemos tener PCs con Windows y PCs con Linux de forma que puedan intercambiar información en carpetas compartidas de la misma forma que se haría si todos los PCs fueran Windows.
Para que la información entre las páginas web este sincronizada y sea igual en los dos servidores, montaremos un servicio samba para compartir la carpeta de archivos de configuración y a partir de ahí usar estos archivos en los dos dockers de los web-backend.
Instalación Samba Server
Para instalar Samba Server haremos:
sudo apt install samba
Configuración fichero
Una vez tengamos samba instalado, procederemos a configurar el archivo /etc/samba/smb.conf para compartir la carpeta de nuestros ficheros WordPress y poder trabajar desde esa carpeta.
sudo nano /etc/samba/smb.conf
Una vez dentro, iremos al final del archivo y añadiremos los siguientes parámetros:
[wordpress] path = /home/pi/html/ public = yes writeable = yes comment = smb share guest ok = yes
Le pondremos nombre, en nuestro caso wordpress, y los parámetros se refieren a lo siguiente:
path | Nos indica la ruta de la carpeta que queremos compartir. |
public | Este parámetro es para compartir la carpeta. |
writeable | En el caso que sea yes, tendremos permisos de escritura sobre la carpeta. |
comment | Para poner un comentario o algo descriptivo sobre la carpeta. |
guest ok | Indica que cualquier usuario sin contraseña tiene permiso de acceso. |
Ahora reiniciamos el servicio y ya tendremos nuestra carpeta compartida.
sudo service smbd restart
Filebeat
Filebeat es un cargador de datos de registro para archivos locales. Instalado como un agente en sus servidores, Filebeat supervisa los directorios de registro o archivos de registro específicos, las colas de los archivos, y los reenvía a Elasticsearch o Logstash para la indexación.
Instalación y compilación
Elastic Stack no ofrece soporte para la arquitecta armhf así que tendremos que compilarlo como explicamos a continuación.
Dependencias
Los principales paquetes adicionales requeridos son git, python-pip y virtualenv. Git y python-pip se pueden instalar usando el administrador de paquetes regular:
pi@raspberrypi:~ $ sudo apt-get install python-pip git
Pip se puede usar para instalar virtualenv:
user@raspberrypi:~ $ sudo pip install virtualenv
Go
El componente de beats de ELK está escrito usando go . El paquete predeterminado go-1.7.x que venía con Raspbian siguió arrojando errores durante la compilación. Al momento de escribir, no había disponible un paquete más actualizado, por lo que se utilizó la versión actual disponible en el sitio web principal.
Raspberry Pi se basa en la arquitectura ARMv6. Descargue la versión estable actual de ARMv6 desde el sitio principal de descarga de go - al momento de escribir la guía, la versión actual es 1.9.2.
pi@raspberrypi:~ $ wget https://redirector.gvt1.com/edgedl/go/go1.9.2.linux-armv6l.tar.gz pi@raspberrypi:~ $ sudo tar -C /usr/local -xzf go1.9.2.linux-armv6l.tar.gz pi@raspberrypi:~ $ export PATH=$PATH:/usr/local/go/bin pi@raspberrypi:~ $ go version go version go1.9.2 linux/arm
Vale la pena agregar PATH = $ PATH: / usr / local / go / bin al ~ / .profile o ~ / .bash_profile de la cuenta que se está usando. Esto garantiza que la cuenta pueda seguir utilizándose después del siguiente inicio de sesión.
Downloading & Building filebeat
Primero, debe establecerse una ubicación de directorio para compilar Filebeat. A los fines de esta guía, se utiliza el directorio go bajo el directorio de inicio de los usuarios. La variable de entorno GOPATH debe establecerse en lo que se elija para que el proceso de compilación funcione.
pi@raspberrypi:~ $ export GOPATH=$HOME/go pi@raspberrypi:~ $ mkdir go pi@raspberrypi:~ $ mkdir -p ${GOPATH}/src/github.com/elastic pi@raspberrypi:~ $ cd ${GOPATH}/src/github.com/elastic pi@raspberrypi:~/go/src/github.com/elastic $
Ahora en la construcción.
pi@raspberrypi:~/go/src/github.com/elastic $ git clone https://github.com/elastic/beats.git pi@raspberrypi:~/go/src/github.com/elastic $ cd beats/ pi@raspberrypi:~/go/src/github.com/elastic/beats $ git checkout 1122568 pi@raspberrypi:~/go/src/github.com/elastic/beats $ cd filebeat/ pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ make
go build -i
user@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ make update
Nos deberia de dar un resulta similar al siguiente
New python executable in /home/user/go/src/github.com/elastic/beats/filebeat/build/python-env/bin/python Installing setuptools, pip, wheel...done. find: warning: you have specified the -maxdepth option after a non-option argument -type, but options are not positional (-maxdepth affects tests specified before it as well as those specified after it). Please specify options before other arguments. find: warning: you have specified the -mindepth option after a non-option argument -type, but options are not positional (-mindepth affects tests specified before it as well as those specified after it). Please specify options before other arguments. Updating generated files for filebeat make[1]: Entering directory '/home/user/go/src/github.com/elastic/beats/libbeat' make[1]: Leaving directory '/home/user/go/src/github.com/elastic/beats/libbeat' -- The index pattern was created under /home/user/go/src/github.com/elastic/beats/filebeat/_meta/kibana/5.x/index-pattern/filebeat.json -- The index pattern was created under /home/user/go/src/github.com/elastic/beats/filebeat/_meta/kibana/default/index-pattern/filebeat.json
Dos elementos a tener en cuenta como parte de la construcción de Filebeat:
- El comando de pago de git es importante. Cada versión del plugin beats está diseñada para funcionar con la misma versión de Logstash y Elasticsearch. El código de hash apropiado para la versión de destino se puede encontrar en el sitio de publicación de elástico / tiempos . Cuando ejecute filbeat por primera vez (a continuación), asegúrese de que la versión compilada sea la esperada.
- Se supone que compilar cosas con go toma una gran cantidad de memoria. Algunas de las guías mencionaron la necesidad de aumentar la cantidad predeterminada de archivo de intercambio disponible. Al completar los pasos anteriores en una Raspberry Pi 3 esto no fue requerido.
Activar de módulos
explicacion de que son los modulos y activarlos el modulo de apache2 y filebeat
Antes de seguir estos pasos, verifique que Elasticsearch y Kibana se estén ejecutando y que Elasticsearch esté listo para recibir datos de Filebeat.
Habilitar el módulo:
pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $sudo ./filebeat modules enable apache2 pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $sudo ./filebeat modules enable mysql
Para ver una lista de módulos habilitados y deshabilitados, ejecute:
pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ sudo ./filebeat modules list
Configurar el entorno inicial:
pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ sudo ./filebeat setup -e
Ejecuta Filebeat:
pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $ sudo ./ filebeat -e
Suponiendo que todo vaya bien, ahora debería tener un nuevo ejecutable llamado Filebeat. Ahora se puede ejecutar utilizando los indicadores de línea de comando -e (enviar salida a la consola) y -v (datos de nivel de información de registro) para confirmar que funciona bien.
pi@raspberrypi:~/go/src/github.com/elastic/beats/filebeat $sudo ./ filebeat -e
Servidor en AWS
Para utilizar un software para poder ver información gráfica y visual sobre nuestro IDS (suricata), necesitamos instalar el software que comentaremos ahora. Este software necesita unos requisitos mínimos para que pueda ser instalado y funcione correctamente en nuestra raspberry y esta no los cumple. Para ello, hemos creado una máquina Ubuntu (Linux) en AWS (Amazon Web Service) y poder tenerla en la nube. El software que implementaremos aquí será: Java, Elasticsearch, Kibana.
Java
Java es un lenguaje de programación y una plataforma de computación lanzada por primera vez por Sun Microsystems en 1995. Hay muchas aplicaciones y sitios web que no funcionarán a menos que tenga Java instalado y se creen más todos los días. Java es rápido, seguro y confiable. Desde computadoras portátiles a centros de datos, consolas de videojuegos, supercomputadoras científicas, teléfonos celulares a Internet...
Instalación Java
Primero de todo actualizaremos.
sudo apt update
Una vez actualizado, instalaremos la versión 8 de Java.
sudo apt install default-jre
Para comprobar la versión y ver que se ha instalado correctamente la 8 introduciremos lo siguiente.
java -version
Elasticsearch
Elasticsearch es un motor distribuido de búsqueda y análisis capaz de resolver un número creciente de casos de uso. Como corazón de Elastic Stack, almacena centralmente sus datos para que pueda descubrir lo esperado y descubrir lo inesperado. Para entenderlo mejor, podríamos decir que analiza cierta información de nuestro sistema como pueden ser errores, mensajes de alerta,etc. y los envía a Kibana para que podamos verlo gráfica y visualmente y obtener un informe de información de nuestro interés.
Instalación Elasticsearch
En primer lugar, debemos agregar la clave de firma de Elastic para que se pueda verificar el paquete descargado (omitir este paso si ya ha instalado paquetes de Elastic):
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
Para Debian, necesitaremos instalar el paquete apt-transport-https:
sudo apt install apt-transport-https
El siguiente paso es agregar la definición del repositorio a su sistema:
echo "deb https://artifacts.elastic.co/packages/6.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-6.x.list
Ahora actualizaremos los repositorios e instalaremos Elasticsearch:
sudo apt-get update sudo apt install elasticsearch
Configuración fichero
Las configuraciones de Elasticsearch se realizan usando un archivo de configuración que le permite configurar ajustes generales (por ejemplo, nombre de nodo), así como configuraciones de red (por ejemplo, host y puerto), donde se almacenan datos, memoria, archivos de registro y más.
En nuestro ejemplo, dado que estamos instalando Elasticsearch en AWS, una buena práctica es vincular Elasticsearch a una IP privada o localhost.
Abriremos el archivo /etc/elasticsearch/elasticsearch.yml y dejaremos el archivo del siguiente modo.
sudo nano /etc/elasticsearch/elasticsearch.yml
network.host: "localhost" http.port:9200
Iniciamos el servicio elasticsearch para empezar a usarlo.
sudo service elasticsearch start
Kibana
Kibana nos permite visualizar datos de Elasticsearch, de modo que podemos visualizar información sobre lo que ocurre en nuestro servidor a través de una interfaz web.
Instalación Kibana
Para instalar Kibana sencillamente introduciremos el siguiente comando.
sudo apt install kibana
Ahora abriremos el archivo de configuración de Kibana en /etc/kibana/kibana.yml, y asegúrese de tener las siguientes configuraciones definidas:
server.port: 5601 elasticsearch.url: "http://localhost:9200"
Estas configuraciones específicas le dicen a Kibana a qué Elasticsearch conectarse y qué puerto usar.
Ahora iniciaremos Kibana.
sudo service kibana start
Para empezar a usar kibana tendremos que ir a nuestro navegador e introducir la URL. http://localhost:5601