Guía rápida para crear un servidor web casero con LAMP y WordPress en Rapsberry Pi

Como dice la wikipedia " Wordpress es un sistema de gestión de contenidos enfocado a la creación de cualquier tipo de página web". Y no solo eso, desde la raspberry pi, una vez creado el contenido podremos servir esa página al mundo exterior sin necesidad de contratar un alojamiento en ningún sitio.

Vamos con ello.

1) instalar el servidor web apache

Primeramente y como siempre hacemos procedemos a actualizar el sistema. 

pi@raspberrypi:~ $ sudo apt-get update
pi@raspberrypi:~ $ sudo apt-get full-upgrade

Instalamos el servidor, en este caso apache.

pi@raspberrypi:~ $ sudo apt-get install apache2 -y

Vamos a necesitar conocer la IP de la rapsberry pi en nuestra red local. Si no tienes una dirección estática o no la sabes puedes conocerla con el siguiente comando:

pi@raspberrypi:~ $ hostname -I

Luego abre un navegador web y entra en http://localhost o si es desde otro equipo de la red local con la ip local de la rapsberry que obtuviste con el comando anterior (por ejemplo http://192.168.1.58) y saldrá la página de bienvenida de apache si todo ha ido bien.

2) Instalar php necesario para que funcione wordpress.

> sudo apt-get install php -y

entramos en:

> cd /var/www/html/

borramos index.html 

> sudo rm index.html

y para para comprobar si funciona con un editor de texto, nano por ejemplo (sudo nano index.php), crearemos un archivo llamado index.php con el siguiente contenido.

<?php echo "hello world "; ?>
<?php echo date('Y-m-d H:i:s'); ?>
<?php phpinfo(); ?>

Guardamos el archivo y salimos del editor.

Para comprobar que funciona entramos en un navegador y tecleamos htpp://localhost, o si accedemos desde otro ordenador de nuestra red, tecleamos la dirección IP de la Raspberry.

Deberíamos ver esta pantalla.

sino vemos el mensaje podemos probar a reiniciar el servidor web con:

> sudo service apache2 restart

3) Instalar MySQL

Instalamos MariaDb junto con los paquetes PHP_MySQL.

> sudo apt-get install mariadb-server php-mysql -y

volvemos a reiniciar el servidor:

> sudo service apache2 restart

4) Instalar wordpress

Volvemos al directorio /var/www/html/ donde tenemos index.php y una vez dentro borramos todo el contenido.

> sudo rm index.php

Descargamos la versión mas reciente de wordpress con:

> sudo wget http://wordpress.org/latest.tar.gz

extraemos su contenido con:

>  sudo tar xzf latest.tar.gz

Ahora hay que pasar todo el contenido de la carpeta wordpress que se habrá creado en el directorio, a la actual en la que estamos situados (/var/www/html/) con :

> sudo mv wordpress/* .

ordenamos un poco las cosas eliminando el archivo descargado y el directorio wordpress

> sudo rm -rf wordpress latest.tar.gz

Por ultimo damos permisos al usuario Apache para gestionar estos archivos.

> sudo chown -R www-data: .

Lo que sigue hasta el paso 5 es opcional:

Para gestionar la base de datos de forma más visual podemos instalar un gestor de mysql como phpmyadmin.

> sudo apt-get install phpmyadmin

Durante la instalación nos preguntará en que servidor queremos instalarlo

, seleccionaremos apache2. Igualmente indicaremos SI cuando nos pregunte sobre configurar la base da datos para phpMyAdmin con dbconfig-common.

Después nos preguntarán una contraseña para phpMyAdmin. Podemos dejarla en blanco ya que el programa establecerá una aleatoria y nosotros no la necesitaremos el resto del tutorial. Si posteriormente queremos acceder a la base lo haremos con la contraseña del usuario 'root' que configuraremos luego. 

Finalmente, cuando haya terminado necesitamos editar una línea para indicarle a Apache que hemos instalado PHPMyAdmin. Para ello:

> sudo nano /etc/apache2/apache2.conf

y añadiremos el final de este archivo lo siguiente:

Include /etc/phpmyadmin/apache.conf

Una vez realizado, salvamos presionado CTRL + X y pulsamos Y para aceptar los cambios.

Reiniciamos Apache:

> sudo service apache2 restart

y comprobamos que se ha instalado correctamente accediendo a la siguiente url desde nuestro navegador en la Raspberry Pi http://localhost/phpmyadmin o bien desde otro equipo de la misma red con http://direción_IP_PI/phpmyadmin. Deberíamos ver algo similar a:

5) Configurar la base de datos de wordpress

Procedemos a configurar la base de datos antes de iniciar wordpress.

> sudo mysql_secure_installation 

Vamos contestando a las preguntas que nos hace el programa.

Lo primero que nos dicen es que pongamos la contraseña root de la base de datos, pero como acabamos de instalarla aun no tiene ninguna contraseña así que le damos un intro para dejarla en blanco.

A continuación si que ya ponemos una contraseña para el usuario root de la base de datos , seleccionando "yes" en la pregunta de que si queremos contraseña y la confirmamos.

A todas las demás preguntas que nos haga las dejamos en la opción por defecto dándole al intro.

5.a. Creamos la base de datos para wordpress con:

> sudo mysql -uroot -p

Lógicamente usamos la contraseña que elegimos antes.

Luego  vamos a crear una base de datos que se llamará wordpress, y le damos privilegios para poder acceder a ella al usuario 'root':

MariaDB [(none)]> create database wordpress;

MariaDB [(none)]> GRANT ALL PRIVILEGES ON wordpress.* TO 'root'@'localhost' IDENTIFIED BY 'PASSWORD';

Importante: sustituye la palabra PASSWORD por la contraseña que le hayas puesto al usuario 'root'.

MariaDB [(none)]> FLUSH PRIVILEGES;

Salimos del programa pulsando ctrl + d.

6.) Entramos en Wordpress y acabamos de rematar el proceso.

Ahora que lo tenemos todo preparado es hora de entrar en Wordpress. Para ello como hemos hecho hasta ahora, en un navegador acedemos al localhost o si como en mi caso lo estas haciendo desde otro equipo usamos la dirección Ip de la Rapsberry en nuestra red. Nos aparecerá la página de configuración inicial de Wordpress.

Escogemos el idioma de la aplicación que queremos y le damos a continuar. Nos aparecerá la pantalla de Bienvenida.

Ya en la siguiente pantalla tenemos que poner los datos de configuración de la base de datos que usará wordpress y que ya hemos creado antes.

Cambia la contraseña por la que hayas asignado antes al usuario 'root'. Si todo ha ido bien wordpress se podrá conectar con éxito a la base de datos  y ya casi habremos terminado.

Ya solo nos queda elegir un nombre para nuestro sitio web, elegir un nombre de usuario y una contraseña (recuerda ambos que sino luego no podrás entrar) y poner nuestro correo electrónico.

Cuando hayas terminado el programa de instalación nos dirá que ha finalizado y a continuación ya aparecerá la página para logearnos en wordpress y poder empezar a crear nuestro sitio web.

y con esto ya habremos terminado. 

Y mientras tengas la rapsberry pi encendida tu sitio web estará disponible y en funcionamiento. 

    

Comunicación entre contenedores e introducción a Docker Compose.

Anteriormente vimos como se trabaja con un contenedor de Docker. En este capítulo vamos a ir un poco más allá y ver como podemos trabajar con varios contenedores que además estén conectados entre si. Para ello vamos a utilizar con un ejemplo práctico que es como enlazar un contenedor que tenga phpMyAdmin con uno que este ejecutando Mysql o Mariadb.

1.1 Requisitos.

Para poder ejecutar contenedores de Docker lo primero es tener Docker Community Edition (CE) instalado. Puedes ver como hacerlo en el capitulo que previamente vimos sobre Docker. En este ejemplo yo estoy trabajando en una maquina con Linux.

1.2 Enlazar un contenedor PhpMyAdmin con otro que contenga MariaDB o MySQL.

Lo primero que tenemos que hacer es descargar las imágenes de Docker Hub de PhpMyAdmin y de por ejemplo MariaDB. 

$ docker pull phpmyadmin

y

$ docker pull mariadb

Para conectar dos contenedores podemos hacerlo de dos formas.

1.2.1 Usando el parámetro --link.

Los enlaces permiten que los contenedores se reconozcan entre si y transfieran información de forma segura de un contenedor a otro. Para crear un enlace utilizaremos el parámetro --link.

docker run -d \
--rm \
--name mibase \
-p 3306:3306 \
-e MARIADB_ROOT_PASSWORD=contraseña \
mariadb:latest

Una vez que el contenedor de Mariadb esta en ejecución procedemos a crear el contenedor de PhpMyAdmin. 

docker run -d \
--rm \
--name phpmyadminc \
--link mibase \
-e PMA_HOST=mibase \
-p 8080:80 \
phpmyadmin

La variable de entorno PMA_HOST, como nos dice las instrucciones que podemos encontrar en docker hub sobre PhpMyAdmin nos sirve para indicar el nombre del contenedor al que nos queremos conectar desde PhpMyAdmin.

Con el parámetro --link hemos creado un enlace entre ambos contenedores 

Para comprobar que todo funciona bien, abrimos un navegador web y accedemos a la dirección:

http:/localhost:8080

En este caso, tal como especificamos, usando el usuario root y el password "contraseña" nos debería funcionar bien.

1.2.1 Usando un "user-defined bridge network".

Para empezar creamos el "user-defined bridge network"

docker network create mi_red

La idea es que los contenedores usen esa red que hemos creado como puente de comunicación entre ellos.

Por tanto ejecutamos el contenedor para Mariadb de una forma muy parecida a como lo hicimos anteriormente, solo que especificando que usen "mi_red" como medio de comunicación.

docker run -d \
--rm \
--name mibase \
--network mi_red \
-p 3306:3306 \
-e MARIADB_ROOT_PASSWORD=contraseña \
mariadb:latest

y hacemos lo mismo con el contenedor de PhpMyAdmin especificando también que use como puente de comunicación "mi_red" y también no olvidemos la variable de entorno "PMA_HOST"

docker run -d \
--rm \
--name phpmyadminc \
--network mi_red \
-e PMA_HOST=mibase \
-p 8080:80 \
phpmyadmin

Para comprobar que todo funciona bien volvemos a abrir un navegador web y entramos en la siguiente dirección http:/localhost:8080. Si todo va bien nos saldrá la pantalla de phpmyadmin en donde podremos loguearnos.

Al igual que podemos eliminar los contenedores, también podemos eliminar la conexión de red que hemos creado. Para ello basta con teclear el siguiente comando:

docker network rm mi_red

En los ejemplos anteriores al cerrar los contenedores se nos perdía la información. Vamos a ver ahora un ejemplo en el que usaremos ambos contenedores pero usando persistencia de datos, es decir que cuando cerremos los contenedores la base que creemos quede guardada en nuestro ordenador.

1.3 Ejemplo de uso con persistencia de datos de PhpMyAdmin y MariaDb.

En los ejemplos anteriores al cerrar los contenedores perdíamos toda la información, desaparecían las bases de datos que hubiésemos creado. En este ejemplo vamos a hacer los mismo, pero de forma que la información sobre la base de datos que creemos, se guarde de unas sesiones a otras.

Con el argumento -v vinculamos un directorio que esta en nuestro ordenador con el directorio de destino en el contendor. Como los datos de las bases de datos en el contenedor se guardan en el directorio /var/lib/mysql para vincularlos ejecutaré la siguiente sentencia pero entrando primeramente en el directorio de mi ordenador donde quiero que se guarden los datos (o vincular mejor dicho). En vez de usar "$(pwd)"  también se puede poner directamente el directorio absoluto a donde queremos vincular los datos.

docker run -d \
--rm \
--name mibase \
-p 3306:3306 \
-e MARIADB_ROOT_PASSWORD=contraseña \
-v $(pwd):/var/lib/mysql \
mariadb:latest

Creamos un contenedor con PhpMyAdmin que esté enlazado con el contenedor anterior.

docker run -d \
--rm \
--name phpmyadminc \
--link mibase \
-e PMA_HOST=mibase \
-p 8080:80 \
phpmyadmin

Para ver si funciona entramos en phpmyadmin y creamos una nueva base de datos. Yo la llamaré "mibasededatos"

Ahora cerramos todo y volvemos a hacer lo mismo, para ver si se han vinculado correctamente los datos y la base de datos que hemos creado no ha desaparecido al cerrar los contenedores. No obstante si entras en el directorio del ordenador que has elegido para vincular los datos verás como antes estaba vacío y ahora contiene los datos que se han ido vinculando.

Efectivamente, ahí sigue la base de datos que hemos creado. Ya que el directorio local esta vinculado con el del contenedor automáticamente.

1.4 Docker Compose.

Tal como nos dice la documentación de Microsoft para VS Code, Docker-Compose es una herramienta desarrollada para ayudar a definir y compartir aplicaciones entre varios contenedores. Tan solo es necesario crear un archivo YAML para definir los servicios y, con un solo comando, ponerlo todo en marcha o eliminarlo.

1.4.1 Instalación de Docker Compose.

En la documentación de Docker se especifica como instalarlo en cualquier sistema operativo. Yo voy a seguir las instrucciones para instalarlo en Linux. 

Lo primero es ejecutar la siguiente instrucción para descargar la versión estable de Docker-Compose:

 $ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Luego le damos permisos de ejecución al binario que nos hemos descargado.

$ sudo chmod +x /usr/local/bin/docker-compose

Para finalizar comprobamos que la instalación haya finalizado correctamente:

$ docker-compose --version
docker-compose version 1.29.2, build 5becea4c

1.4.2. Creación del archivo docker-compose.yml con Mariadb y PhpMyAdmin.

1.- En la raíz del proyecto de la aplicación, crearemos un archivo llamado docker-compose.yml con el que ejecutaremos dos servicios Mariadb y PhpMyAdim.

2.- En el archivo de Compose, lo primero que tenemos que definir es la versión del esquema del archivo YAML que vamos a utilizar. En la mayor parte de los casos lo mejor es utilizar la última versión. Podemos consultar las versiones de esquema y sus compatibilidades en la referencia de archivos de Compose.

Archivo docker-compose.yml

version: "3.8"

3.- A continuación, definimos la lista de servicios o contenedores que queremos ejecutar como parte de la aplicación. Podemos poner el nombre de los servicios como nosotros queramos. En este caso lo típico sería usar como nombre de servicio Mariadb y PhpMyAdmin pero para ver que podemos cambiar de nombre usaremos miBase y miPhpmyadminc. El nombre que utilicemos para los servicios, que hemos elegido libremente, se convertirá automáticamente en un alias de red, lo que nos será muy útil al definir el servicio para Mariadb.

Archivo docker-compose.yml

version: "3.8"

services: 
    miBase:

    miPhpmyadminc:

4.- Lo siguiente a hacer es ir pasando o traducir todas las instrucciones que hemos usado anteriormente para ejecutar los contenedores a este archivo. Por ejemplo para crear ejecutar MariaDb y PhpmyAdmin con persistencia de datos usamos las siguientes instrucciónes.

docker run -d \
--rm \
--name mibase \
-p 3306:3306 \
-e MARIADB_ROOT_PASSWORD=contraseña \
-v $(pwd):/var/lib/mysql \
mariadb:latest

docker run -d \
--rm \
--name phpmyadminc \
--link mibase \
-e PMA_HOST=mibase \
-p 8080:80 \
phpmyadmin

Ahora en el archivo yaml en el que hemos puesto el nombre de los servicios, tenemos que poner que imágenes se van a utilizar.  

Archivo docker-compose.yml

version: "3.8"

services: 
    miBase:
        image: mariadb:latest

    miPhpmyadminc:
        image: phpmyadmin:latest

Para traducir los puertos, cambiamos el argumento -p por la clave "ports" de la siguiente forma:

Archivo docker-compose.yml

version: "3.8"

services: 
    miBase:
        image: mariadb:latest
        ports:
            - 3306:3306
    miPhpmyadminc:
        image: phpmyadmin:latest
        ports:
            - 8080:80

Continuamos traduciendo las variables de entorno que utilizan cada uno de los contenedores. En vez del argumento -e utilizamos la clave "environment"

Archivo docker-compose.yml

version: "3.8"

services: 
    miBase:
        image: mariadb:latest
        ports:
            - 3306:3306
        environment:
            - MARIADB_ROOT_PASSWORD=contraseña

    miphpmyadminc:
        image: phpmyadmin:latest
        ports:
            - 8080:80
        environment:
            - PMA_HOST=miBase
   

Como hemos usado persistencia de datos para guardar las bases de datos que creemos en el directorio que estemos trabajando del ordenador, sustituimos el argumento -v por la clave "volumes". Si hubiésemos especificado un directorio de trabajo en Docker utilizaríamos la clave "working_dir" aunque en este ejemplo no es el caso. 

Una cosa importante es que cuando usamos docker run para ejecutar los contenedores, se crea automáticamente el volumen con su nombre. Pero esto no sucede cuando se ejecuta Compose. Aquí tenemos que definir el volumen en la sección volumes: de nivel superior, y después, especificar el punto de montaje en la configuración del servicio. Para que se usen las opciones predeterminadas solo se tiene que proporcionar el nombre del volumen. Pero hay muchas más opciones disponibles.

IMPORTANTE: cuando ejecutamos en los ejemplos anteriores docker run con la opcion -v para tener persistencia de datos, utilice $(pwd) para que se creara la sincronización dentro del directorio con el que estamos trabajando. Sin embargo esto no funciona en docker Compose que se basa en python. Podemos hacer la persistencia de otra forma que también nos valdría para el caso de que usemos docker run que es creando un volumen de docker. 

Para crear un volumen de Docker usamos la instrucción:

$ docker volume create Nombre_del_volumen

Por ejemplo, yo para usar en el archivo yaml crearé uno llamado "almacen"

$ docker volume create almacen

Esto creará un espacio donde se sincronizarán los datos en nuestro disco local, fuera del contenedor o contenedores. Para obtener información y poder localizar donde están los archivos podemos usar:

$ docker volume inspect almacen
[
    {
        "CreatedAt": "2021-09-19T18:59:27+02:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/almacen/_data",
        "Name": "almacen",
        "Options": {},
        "Scope": "local"
    }
]

Tenemos opciones para crear, inspeccionar, listar o eliminar los volúmenes que hayamos creado, lo mismo que para los contenedores.

Así nuestro archivo yaml para persistencia quedaría de la siguiente forma.

Archivo docker-compose.yml

version: "3.8"

services: 
    miBase:
        image: mariadb:latest
        ports:
            - 3306:3306
        environment:
            - MARIADB_ROOT_PASSWORD=contraseña
        volumes:
            - almacen:/var/lib/mysql

    miPhpmyadminc:
        image: phpmyadmin:latest
        ports:
            - 8080:80
        environment:
            - PMA_HOST=miBase
volumes:
    almacen:

Para finalizar usamos la clave depends_on para indicar al servicio miPhpmyadminc que no se ejecute hasta que el servicio miBase se haya iniciado.

Archivo docker-compose.yml

version: "3.8"

services: 
    miBase:
        image: mariadb:latest
        ports:
            - 3306:3306
        environment:
            - MARIADB_ROOT_PASSWORD=contraseña
        volumes:
            - almacen:/var/lib/mysql

    miPhpmyadminc:
        image: phpmyadmin:latest
        ports:
            - 8080:80
        environment:
            - PMA_HOST=miBase
        depends_on:
            - miBase
volumes:
    almacen:
        

5.- Para ejecutar nuestro archivo docker-compose.yml ejecutamos, desde donde este se encuentre:

$ docker-compose up -d

En donde la opcion -d es para que se ejecute en segundo plano.

Para comprobar que funciona volvemos a abrir el navegador web, ir al localhost:8080 y ver si podemos logearnos en Phpmyadmin y crear nuestra base de datos que conservará los datos una vez hayamos cerrado los contenedores.

Otros comandos útiles que podemos utilizar con Docker-compose son:

- docker-compose up crea y ejecuta una colección de contenedores.

- docker-compose stop detiene los contenedores.

- docker-compose start inicia los contenedores.

- docker-compose down detiene y retira los contenedores.

Apendice. Uso de MySql o MariaDB en un proyecto Flask.

Anteriormente. FLASK 20 Desplegar una aplicación en Flask con Nginx y Gunicorn.

La base de datos que he usado durante el desarrollo del proyecto está muy bien para aplicaciones simples, pero si queremos implementar un servidor web completo, que puede necesitar manejar multiples solicitudes a la vez, es mejor utilizar una base de datos más robusta. Por esa razón voy a explicar como configurar una base de datos de tipo MySql en concreto MariaDB.

MariaDb es una base de datos opensource basada en MySql y que es compatible con la misma.

Lo primero que haré será instalarlo. Para ello abrimos un terminal y comenzamos actualizando los repositorios:

$ sudo apt-get update
$ sudo apt-get full-upgrade

Una vez actualizado el software de la Raspberry, procedemos a instalar MariaDB:

$ sudo apt-get install mariadb-server 

Con esto ya tenemos instalado MariaDB. Ahora vamos a tratar de configurarlo. Para ello escribimos el siguiente comando:

$ sudo mysql_secure_installation

Este comando aunque se llame mysql se puede usar con MariaDB. Lo primero que nos pide es que escribamos nuestra contraseña actual, pero como acabamos de instalarla no tenemos ninguna por lo que simplemente le damos un Enter.

Luego nos pregunta si queremos establecer una contraseña para el usuario root. Yo no voy a ponerla con lo cual presiono "n". (pero tu puedes ponerla sin problemas)

A continuación nos pregunta si queremos eliminar los usuarios anónimos, lo que si vamos a hacer. Presionamos "y"

También nos pregunta si queremos desactivar el acceso remoto, a lo que contestamos que si ya que en nuestro proyecto todas las consultas a la base de datos se realizarán de forma local.

Nos preguntará si queremos eliminar la base de datos de prueba a lo que también contestamos que si. "y"

Y para finalizar nos dirá si queremos recargar los privilegios de la tabla ahora. Contestamos que si "y"

Y ya la tenemos configurada. Otra forma es dejar las opciones por defecto pulsando simplemente Enter a cada pregunta lo que viene a ser los mismo.

Para ver que versión tenemos instalada podemos teclear:

$ mysql --version

Bien ahora que ya lo tenemos preparado vamos a ejecutar MariaDB, 

$ sudo mysql

Este comando nos conecta con MariaDB y nos mostrará su prompt donde podemos crear base de datos, usuarios etc. 

Pero lo primero que tenemos que hacer es crear un usuario nuevo adicional con privilegios que es el que usaremos en nuestro proyecto. Ejecutaremos el siguiente comando:

MariaDB [(none)]> GRANT ALL ON *.* TO 'usuario'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;

En donde 'usuario' es el nombre del nuevo usuario que utilizaremos en nuestra base de datos.

En donde 'localhost' es la dirección de red de la base de datos, en nuestro caso al trabajar en local usaremos localhost.

En donde 'password' es la contraseña del usuario para la base de datos.

Voy a comprobar si todo ha quedado bien. Para ello reiniciamos la tabla para que pueda reconocer mi nuevo usuario.

MariaDB [(none)]> FLUSH PRIVILEGES;

Ahora ya podemos salir de la base de datos con:

MariaDB [(none)]> EXIT;

y testearemos si mariadb está ejecutándose  y el usuario ha quedado bien registrado.

$ sudo systemctl status mariadb

Vemos que el servicio mariadb esta activo y ejecutándose y si queremos saber más sobre el shell de MariaDB podemos usar:

$ sudo mysqladmin version

ffgfg

Vamos a testear nuestro nuevo usuario. Para ello nos volveremos a conectar con el nuevo usuario que hemos creado.

$ mysql -u usuario -p

Nos preguntará la contraseña que hemos definido antes y si todo ha ido bien, veremos algo como esto:

Y desde aquí ya podemos crear la base de datos que vamos a utilizar en el proyecto.

MariaDB [(none)]> create database mibase;

o si quieres crear la base de datos usando el juego de caracteres utf-8:

MariaDB [(none)]> CREATE DATABASE mibase CHARACTER SET utf8 COLLATE utf8_bin;

Nota: si te confundes de nombre de la base y quieres borrarla, si tienes permisos sobre ella puedes hacerlo con:

MariaDB [(none)]> DROP DATABASE nombre_de_la_base_a_borrar;  

Podemos ver si ha quedado correctamente creada usando el siguiente comando, que nos muestra las bases de datos que tiene asignadas mariadb:

MariaDB [(none)]> show databases;

En el post anterior de como desplegar una aplicación en raspberry pi hemos utilizado la aplicación del post 19 así que vamos utilizar ese ejemplo, para pasar de una base de datos sqlite que utiliza a MariaDB. 

IMPORTANTE: para que todo funcione correctamente tenemos que instalar un driver que haga de enlace o controle la base de datos MariaDB desde python. Esto es muy sencillo solo tenemos que instalar el  paquete pymysql dentro de nuestro entorno virtual.

Entramos en el entorno virtual de la aplicación de ejemplo:

pi@raspberry:~/miproyecto $ source ./miEntorno/bin/activate

e instalamos el siguiente paquete, que es el driver que nos va a servir de enlace:

(miEntorno) pi@raspberry:~/miproyecto $ pip install pymysql

Como ya vimos en el post 14 sobre Flask para dejar de usar sqlite y usar la base de datos que hemos creado tendremos que hacer unos sencillos pasos, además de instalar el driver que acabamos de  hacer.

1) En el archivo de configuración de nuestra aplicación (config.py) tenemos que cambiar el conector de sqlite y usar el conector de Mariadb.

Si usaste tu propio nombre de usuario, contraseña o nombre de la base de datos tendrás que modificarlo en el conector.

Los míos eran:

usuario = usuario

contraseña = password

nombre de la base de datos mariadb = mibase

2) Migración de la base de datos creada, pero no hemos adaptado su estructura a los campos que ya tenemos creados en la aplicación. Para eso tenemos que realizar una migración. Seguimos los siguientes pasos.

a) Instalamos, sino lo tenemos ya, el paquete flask-migrate

(miEntorno) $ pip install flask-migrate

Ahora tenemos que importarlo y declararlo en el archivo de la aplicación inicio.py.

Bien como nuestra aplicación inicial, no se llama app.py ni wsgi.py, tenemos que decirle a Flask, para que haga lo mostraré a continuación, cual es nuestra aplicación principal. Para ello solo tenemos que teclear lo siguiente:

(miEntorno) $ export FLASK_APP=inicio.py

Esto solo dura mientras tengas la sesión abierta, si la cierras y vuelves a entrar tendrás que teclearlo de nuevo.

Vamos al lio. Alembic (el framework de migración utilizado por Flask-Migrate) va a realizar los cambios en la estructura de la base de datos de forma que no tengamos que volver a crearla desde cero.  Pues bien, una vez que le hemos dicho a flask cual es nuestra aplicación principal tecleamos:

(miEntorno) $ flask db init
creating directory /14/migrations ...  done
  Creating directory /14/migrations/versions ...  done
  Generating /14/migrations/alembic.ini ...  done
  Generating /14/migrations/README ...  done
  Generating /14/migrations/env.py ...  done
  Generating /14/migrations/script.py.mako ...  done
  Please edit configuration/connection/logging settings in '/14/migrations/alembic.ini' before proceeding.

Después de haber ejecutado este comando te encontrarás un nuevo directorio en el directorio de trabajo llamado migrations con unos cuantos archivos y un subdirectorio llamado versions (que contendrá las modificaciones que hagamos a la estructura de la base de datos)

Cuando hagamos una migración, Alembic, comparará la estructura almacenada en sus directorios con la actual que tengamos definida en nuestro programa y realizará los cambios. Como esta es la primera vez que ejecutaremos el comando y previamente no hay nada, lo que hará será crear tanto el archivo de la base de datos como su estructura. Y lo creará en el directorio y con el nombre que hayamos especificado dentro del archivo de configuración del proyecto, en nuestro caso en:

# Cadena de conexion
SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://usuario:password@localhost/mibase'

b) Realizamos la migración. Nos situamos en el mismo directorio donde está inicio.py, si no estamos ya, y tecleamos:

(miEntorno) pi@raspberry:~/miproyecto $ flask db migrate -m "migracion mariaDB"
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.autogenerate.compare] Detected added table 'usuario'
  Generating
  /home/pi/miproyecto/migrations/versions/2fa6cb75c75d_migracion_mariadb.py ...  done

El programa acaba de generar un script para poder migrar la base de datos con un identificador único 2fa6cb75c75d (en tu caso será otro distinto). El comentario de la opción -m es opcional y añade una breve descripción de texto a la migración.

c) Consolidar la migración. 

(miEntorno) pi@raspberrry:~/miproyecto $ flask db upgrade
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.runtime.migration] Running upgrade  -> 2fa6cb75c75d, migracion mariaDB

Y listo ya tenemos nuestra base de datos, mibase, con sus tablas y sus registros preparados y listos para trabajar. 

Instalar phpMyadmin para gestionar nuestra base de datos MariaDB.

PhpMyAdmin es una herramienta escrita en php con la intención de poder manejar bases de datos de tipo Mysql a través de páginas web, utilizando un navegador web. Con el podemos hace de todo en la base de datos mysql de una forma visual.

 Actualmente puede crear y eliminar Bases de Datos, crear, eliminar y alterar tablas, borrar, editar y añadir campos, ejecutar cualquier sentencia SQL, administrar claves en campos, administrar privilegios, exportar datos en varios formatos y está disponible en 72 idiomas

El método para realizar la instalación, es tener primero tanto el apquete mariadb-server como maríadb-client. Luego podemos instalar phpmyadmin con el siguiente comando:

• $ sudo apt-get install phpmyadmin

Durante la instalación nos preguntará que servidor queremos utilizar para sevir las páginas si apache o ligthtpd. Si quieres usar nginx también se puede. Puedes conseguir información en esta web.

Si todo ha ido correcto al ir al navegador y teclear:

https://nombredelservidor_or_IP/phpmyadmin

Deberías ver la pantalla de bienvenida y a partir de ahí con el usuario que hemos definido previamente poder entrar en la aplicación.

Puedes encontrar más información sobre instalar phpMyAdmin es el blog "usuariodebian.blogspot.com"

Código del Capitulo en GitHub. Ten en cuenta que la base de datos mibase no está incluida tienes que crearla tu y cambiar el conector por el nombre de tu usuario y contraseña ya que se partio en el ejemplo de una base sqlite3.

Próximo Capítulo. Desplegar una aplicación de Flask en Heroku.