---
title: LAMP paso a paso en tu servidor
url: https://jarroba.com/lamp-paso-a-paso-en-tu-servidor/
author: Ramón Invarato
date: 2019-09-30
modified: 2026-10-21
language: es
license: CC BY-NC-SA 3.0 (https://creativecommons.org/licenses/by-nc-sa/3.0/) — attribution: "LAMP paso a paso en tu servidor", Ramón Invarato, jarroba.com
categories: Tecnologias Web
repository: https://github.com/Invarato/JarrobaWeb/tree/master/AvanzadoPHP
---

# LAMP paso a paso en tu servidor

> Aprender paso a paso a crear una web dinámica con la arquitectura LAMP completa: Linux, Apache, MySQL o MariaDB, PHP, Perl o Python.

Si ya sabes crear una web estática o has seguido [el artículo anterior sobre usar servidores y crear una web estática](https://jarroba.com/usar-servidores-y-crear-una-web/), es muy interesante ir un paso más allá y aprender con detalle cómo **crear una web dinámica en la que podamos guardar datos en una base de datos y poder ejecutar código desde el servidor web** de Apache mediante PHP. A continuación te convertirás en un experto y podrás hacer cualquier cosa que te imagines, luego quedará profundizar en cada una de las partes que te sean más interesantes.

 

Para **crear una web dinámica** podremos utilizar una de las arquitecturas existentes. Aquí nos centraremos en**la arquitectura LAMP completa** que viene a significar que necesitamos:

 
- **L**inux: si ya lo tienes perfecto, o si lo has preparado siguiendo [el artículo anterior sobre como crear una web](https://jarroba.com/usar-servidores-y-crear-una-web/) y [el artículos sobre como funcionan los servidores y servicios de hosting](https://jarroba.com/como-funcionan-los-servidores-y-servicios-de-hosting/), entonces ya tenemos esta parte más que preparada (concretamente la distribución Linux de Ubuntu).
- **A**pache: continuaremos suponiendo que tienes el servidor Software de Apache instalado y funcionando (tienes [cómo se instala el servidor Apache con todo detalle en el artículo anterior](https://jarroba.com/usar-servidores-y-crear-una-web/))
- **M**ySQL o **M**ariaDB: un servidor de base de datos (también llamado “gestor de base de datos”) que nos falta e instalaremos ahora, podremos elegir el servidor de base de datos que queramos. Aquí utilizaremos MySQL, que es bastante usado.
- **P**HP, **P**erl, **P**ython: algún lenguaje interpretable del servidor web. Aquí nos decantaremos por PHP, que también suele ser bastante usado con la combinación de Apache y MySQL.

 

Antes de continuar, he de indicar que voy a explicar cada punto con sumo detalle para que aprendas lo máximo, sobre todo si estás empezando. Si eres de los que ya tienen conocimientos más que de sobra sobre LAMP (o si ya te has leído este artículo al completo) y quieres un resumen rápido, lo tienes en [el artículo de sobre como configurar un Apache en servidor Linux](https://jarroba.com/configurar-un-apache-en-un-servidor-linux-digitalocean-con-dominio-y-subdominios-partei/).

 

 

## Servidor Base de datos MySQL

 

**Instalemos la última versión del servidor de base de datos MySQL** con (como siempre, pedirá confirmación para instalar, pulsa “Y” y “Enter” cuando lo pida):

 

```bash
sudo apt install mysql-server
```

 

Al terminar de instalar, el servidor de base de datos MySQL se habrá iniciado solo.

 

#### **Comandos útiles del servidor de base de datos MySQL**

 

**Nota:** No es necesario que utilices estos comando justo ahora mismo; te los pongo aquí porque son bastante útiles por si tienes algún problema con el servidor Software de MySQL

 

Ver el **estado** del servidor MySQL:

 

```bash
sudo service mysql status
```

 

**Detener** el servidor MySQL:

 

```bash
sudo service mysql stop
```

 

**Iniciar** al servidor MySQL:

 

```bash
sudo service mysql start
```

 

**Reiniciar** el servidor MySQL (realiza un stop y un start):

 

```bash
sudo service apache2 restart
```

 

Si quieres ver más, tienes toda la información en la documentación oficial: [A Quick Guide to Using the MySQL APT Repository (MySQL docs)](https://dev.mysql.com/doc/mysql-apt-repo-quick-guide/en/)

 

 

### Abrir el puerto de MySQL en el Firewall

 

**Es necesario tener abierto en tu Firewall el puerto de MySQL**, que va a ser por defecto **3306**.

 

Es muy sencillo, es [se hace de la misma manera a como lo vimos en el anterior artículo](https://jarroba.com/usar-servidores-y-crear-una-web/).

 

**Vamos al “panel de control” de nuestro servidor físico**, que será donde añadamos una nueva norma (regla) en el Firewall.

 

Por ejemplo, [si has seguido los anteriores artículos](https://jarroba.com/usar-servidores-y-crear-una-web/), hemos utilizado [clouding.io](https://clouding.io/). Por lo que **en la sección “Servidores” y en “Mis firewalls”**podremos seleccionar el que use nuestro Servidor Cloud VPS (que en mi ejemplo es “default”); en la barra azul que pone “Normas del Firewall” pulsaremos el “+” para introducir una norma nueva a este Firewall; **en la norma pondremos TCP y solo para el puerto 3306**:

 

![Captura del panel de control con el firewall «default» y una norma nueva TCP para el puerto 3306 de MySQL](https://jarroba.com/wp-content/uploads/2019/09/Abrir-Firewall-para-MySQL-en-el-panel-de-control-del-servidor-www.Jarroba.png)

 

 

## Configurar la seguridad de MySQL

 

Continuaremos configurando la seguridad de la base de datos con el siguiente comando (configurar la seguridad de la «instancia MySQL» es necesario antes de crear alguna «base de datos MySQL»; es necesario que esté ejecutándose el servicio de mysql-server, asegurar esto con el comando ‘sudo service mysql start’):

 

```bash
sudo mysql_secure_installation
```

 

Nos irá haciendo una serie de preguntas bastante sencillas (la mayoría con escribir «Y» y pulsa la tecla «Enter» vale; es decir, es muy de «siguiente», «siguiente», «siguiente»…. 😉 ):

 
1. **Would you like to setup VALIDATE PASSWORD plugin?**: ¿Quieres crear una contraseña válida? Escribe: **Y** (y pulsa la tecla «Enter»)
2. **Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 0** para permitir desde contraseñas débiles, 1 para permitir desde contraseñas medias, 2 para permitir desde contraseñas fuertes. Recomiendo entre 1 y 2, al ser posible **2** (aunque será más tedioso a la hora de recordar y escribir la contraseña, es mucho más seguro)
3. **Tu contraseña.** Esta contraseña tiene que ser de la fuerza mínima que hemos indicado antes. Escribe tu contraseña (yo para estos ejemplos he escrito: grY3h5%5dDsJJbdXj ; no copies esta contraseña para usarla, ya que al publicarla se ha vuelto insegura y conocida por todos)
4. **Do you wish to continue with the password provided?**: ¿Continuar con la contraseña introducida? Ofrecerá una estimación de la fuerza de la contraseña (en “Estimated strength of the password”, recomiendo 100). Si estamos contentos con la contraseña: **Y**
5. **Remove anonymous users?**: ¿Eliminar usuario anónimo? Un usuario por defecto que es poco seguro. Para eliminarlo: **Y**
6. **Disallow root login remotely?**: ¿Deshabilitar inicio remoto de root? Para deshabilitarlo: **Y**
7. **Remove test database and access to it?**: ¿Eliminar base de datos de prueba y su acceso? Es una base de datos con unos pocos datos falsos para jugar. Para eliminarla: **Y**
8. **Reload privilege tables now?**: ¿Recargar tablas de privilegios ahora? Que las tablas de privilegios vuelvan a estar por defecto. Para recargarlas: **Y**

 

A continuación te facilito una imagen completa con todo lo que yo he rellenado:

 

![Captura de la terminal ejecutando mysql_secure_installation con las respuestas rellenadas para instalar MySQL con seguridad](https://jarroba.com/wp-content/uploads/2019/09/Instalar-MySQL-con-seguridad-www.Jarroba-757x1024.png)

 

Las bases de datos son bastante sencillas, pero hay que tener un par de cosas claras antes de continuar:

 
- El **servidor/gestor de bases de datos** puede **tener** múltiples **bases de datos**
- **Una base de datos** puede **tener** múltiples **tablas**
- **Una base de datos** puede estar **gestionada por** múltiples **usuarios**
- **Un usuario tendrá una serie de permisos** sobre unas bases de datos y sobre unas tablas (por ejemplo, alguien que solo pueda leer información, que no tenga la opción de liárnosla borrándola)
- **Los datos se guardan en**filas de las**tablas**
- **Las consultas se hacen sobre** una o varias **tablas**

 

Entrar en la consola de MySQL:

 

```bash
mysql
```

 

![Captura de la terminal tras ejecutar el comando mysql, con el prompt de la consola de MySQL](https://jarroba.com/wp-content/uploads/2019/09/Entrar-en-la-línea-de-comandos-de-MySQL-www.Jarroba.png)

 

Aquí hay que entender que vamos a cambiar de una consola a otra. Dejaremos de estar en la consola de Linux y nos hará caso la consola de MySQL (aparece delante de la consola «mysql>»; es decir, en esta consola podremos dar órdenes a nuestra base de datos, pero no al sistema operativo). Que no cunda el pánico, en un par de párrafos más adelante te explico como se sale de esta consola, pero ahora toca aprender cómo se utiliza.

 

**Nota sobre el modo consola de MySQL:**en los siguientes comandos que he escrito he añadido delante la palabra “mysql>”, esta palabra no hay que escribirla (ya está puesta), la dejo para indicar que tiene que escribirse el comando dentro de la consola de MySQL (y no en la de Linux).

 

**Para salir de la consola de MySQL** escribimos la palabra «exit»

 

```sql
mysql> exit
```

 

Y para volver a entrar escribimos la palabra «mysql»

 

```bash
mysql
```

 

Quédate dentro de la consola de MySQL para continuar con el artículo.

 

MySQL permite tener varias bases de datos, todavía no tenemos ninguna creada (recuerda que antes configuramos la seguridad de la «instancia de MySQL», no una «base de datos de MySQL»). Vamos a **Crear una base de datos** con «CREATE DATABASE» que llamaré «MiBaseDeDatos» (llámala como quieras):

 

```sql
mysql> CREATE DATABASE MiBaseDeDatos;
```

 

**Nota por si te has equivocado o quieres borrar la base de datos:** puedes borrar la base de datos con la sentencia «DROP DATABASE» (cuidado con este comando pues si tenemos datos en la base de datos se eliminarán todos; ahora mismo, después de crearla, no tenemos datos, pero más adelante cuando la utilicemos sí; para continuar tienes que tener la base de datos creada):

 

```sql
mysql> DROP DATABASE MiBaseDeDatos;
```

 

Por cierto, en la consola MySQL se llama **«sentencia SQL» a los «comandos» para realizar operaciones que afectan a la base de datos** (y en cualquier consola de base de datos, no es solo en MySQL, también en otras como en SQL Server), y «comandos» a secas son el resto. Es decir, la palabra «exit» de antes era un «comando» y la palabra «CREATE DATABASE» era una «sentencia SQL».

 

Para **usar esta base de datos**MySQL que acabamos de crear **es necesario seleccionarla** con «USE» (esto es así porque podemos crear tantas bases de datos MySQL como queramos y hay que seleccionar la que queremos usar; al crearla NO se autoselecciona):

 

```sql
mysql> USE MiBaseDeDatos
```

 

![Captura de MySQL creando la base de datos MiBaseDeDatos y seleccionándola con USE](https://jarroba.com/wp-content/uploads/2019/09/Crear-base-de-datos-en-MySQL-www.Jarroba.png)

 

Ahora tenemos que **crear un usuario de la base de datos para que pueda acceder desde el mismo servidor físico** con «CREATE USER» (usaré “localhost” para apuntar al mismo servidor físico, aunque también podría utilizar la IP pública; la fortaleza de la contraseña nos pedirá la que hayamos seleccionado antes):

 

```sql
mysql> CREATE USER 'MiUsuarioDeMiBaseDeDeatos'@'localhost' IDENTIFIED BY 'contraseña de mi usuario';
```

 

**Nota por si quieres borrar un usuario de la base de datos:** puedes borrar un usuario de la base de datos con «DROP USER» (para continuar tienes que tener el usuario de la base de datos creado):

 

```sql
mysql> DROP USER 'MiUsuarioDeMiBaseDeDeatos'@'localhost';
```

 

Como queremos que este usuario sea el que use PHP para gestionar la web para la base de datos que hemos creado con el comando «GRANT» (siempre el tema de los privilegios suena aburrido y complicado; y al contrario, en MySQL son muy pocos, fáciles de poner y bastante deducibles). Le daremos a este usuario **privilegios** de:

 
- **SELECT**: **consultar** los **datos** de una base de datos
- **INSERT**: **insertar** nuevos **datos** en una tabla de una base de datos
- **UPDATE**: **actualizar** **datos** existentes en una tabla de una base de datos
- **DELETE**: **borrar** **datos** existentes en una tabla de una base de datos

 

```sql
mysql> GRANT SELECT, INSERT, UPDATE, DELETE ON MiBaseDeDatos.* TO 'MiUsuarioDeMiBaseDeDeatos'@'localhost';
```

 

El “MiBaseDeDatos.*” indica que le daremos estos privilegios en todas las tablas de la base de datos “MiBaseDeDatos”. Si quisiéramos concretar una tabla dentro de una base de datos pondríamos “MiBaseDeDatos.Tabla_a_la_que_dar_privilegios”

 

Aunque no los vamos a utilizar aquí, te cuento que existen unos pocos privilegios en MySQL por si en un futuro los quieres usar:

 
- **CREATE**: **Crear** una nueva **base de datos**
- **DROP**: **Eliminar** por completo una **base de datos** (ojo con este privilegio, que nos puede traer problemas si permitimos a algún usuario eliminar la base de datos)
- **ALL PRIVIEGES**: Otorga **todos los privilegios** anteriores (en vez de escribirlos todos uno a uno)

 

Ahora vamos a **Crear nuestra primera tabla en nuestra base de datos MySQL** con la sentencia «CREATE TABLE», en el que le diremos las columnas y el tipo de cada una de ellas (el tipo de la columna es si va a ser de tipo texto, tipo número, etc.).

 

Para este ejemplo voy a crear una tabla llamada «MiTAbla» con dos columnas:

 
- **id**: que le diremos que sea número entero, clave primaria (toda tabla necesita una clave primaria) y autoincremental (que se sume 1 al anterior id insertado automáticamente al insertar una nueva fila/registro).
- **correo_electronico**: admita textos de hasta 50 caracteres y que no admita nulos (sin valor).

 

Crearé esta tabla con estos datos escribiendo (la consola de MySQL admite saltos de línea al escribir una sentencia pulsando «Enter», mostrará flechas «->» que indicarán que todavía no se ha cerrado la sentencia; solo cierra y ejecuta la sentencia cuando detecta que hemos escrito un punto y coma «**;**» al final):

 

```sql
mysql> CREATE TABLE MiTabla (
id INT AUTO_INCREMENT PRIMARY KEY,
correo_electronico VARCHAR(50) NOT NULL);
```

 

![Captura de MySQL con la sentencia CREATE TABLE que crea MiTabla con id y correo_electronico](https://jarroba.com/wp-content/uploads/2019/09/Crear-tabla-en-la-base-de-datos-en-MySQL-www.Jarroba.png)

 

 

### **Probar la tabla de la base de datos**

 

Si lo anterior era interesante, ahora lo es más todavía, pues hemos llegado a un punto con «chicha». Probaremos nuestra tabla y veremos que nuestro trabajo funciona 🙂

 

**Insertar un valor de prueba en la tabla** que hemos creado con la sentencia «INSERT INTO»; insertaremos de ejemplo un correo electrónico «jarroba.com@gmail.com» en nuestra columna «correo_electronico» que pertenece a la tabla «MiTabla» (si tienes dudas, más abajo te facilito una imagen esclarecedora con cada uno de los pasos que voy a explicarte):

 

```sql
mysql> INSERT INTO MiTabla (correo_electronico) VALUES ('jarroba.com@gmail.com');
```

 

**Ver los valores de la columna de la tabla** que hemos creado con «SELECT». Para ello le diremos que «seleccione» la columna «correo_electronico» de nuestra tabla «MiTabla» (pues nuestra base de datos MySQL podría tener cientos de tablas de nombre diferentes):

 

```sql
mysql> SELECT correo_electronico FROM MiTabla;
```

 

La sentencia «**SELECT» nos permitirá hacer filtros tan complejos como queramos** (aunque aquí no voy a entrar en muchos detalles, te recomiendo que aprendas a utilizar los filtros «SELECT» más complejos, pues hoy día es una herramienta muy potente y en la profesión de informática es tan básica y necesaria como el saber «sumar» o «teclear»; [para ello te ofrecemos gratis un curso de base de datos completo pinchando aquí](https://jarroba.com/curso-de-bases-de-datos-con-mysql-parte-i-video-instalacion-del-mysql-server-y-workbench/), aunque para este artículo no necesitarás conocer más). Una sentencia sencilla para ver todo lo que contiene nuestra tabla (poniendo asterisco «*****» indica quiero que se vean todas las columnas):

 

```sql
mysql> SELECT * FROM MiTabla;
```

 

Para borrar el dato de la tabla podremos seleccionarlo con el Id (que para eso lo hemos creado, además es único; correos electrónicos podríamos tener repetidos y no querer borrarlos todos):

 

```sql
mysql> DELETE FROM MiTable WHERE id=1;
```

 

Y aquí te dejo la imagen que te indiqué antes con cada uno de los pasos y su resultado:

 

![Captura de MySQL insertando, consultando y borrando un registro de MiTabla con INSERT, SELECT y DELETE](https://jarroba.com/wp-content/uploads/2019/09/insertar-y-ver-valores-en-tabla-en-la-base-de-datos-en-MySQL-www.Jarroba.png)

 

Al final aplico un “SELECT *” para ver que se ha borrado.

 

 

## PHP

 

Para **instalar la última versión de PHP** (pulsar “Y” y “Enter” cuando lo pida):

 

```bash
sudo apt install php
```

 

Cuando esté instalado ya podremos usarlo.

 

**Nota para la conexión PHP con MySQL:** sino trae el módulo de php-mysql hay que instalarlo con (si lo trae, puede no ser necesario instalarlo; sino tampoco hace daño reinstalarlo. Si tienes curiosidad por conocer los módulos que puedes usar en PHP, los puedes consultar en: [Alphabetical (Manual de PHP)](https://www.php.net/manual/en/extensions.alphabetical.php)):

 

```bash
sudo apt install php-mysql
```

 

Y es necesario es **reiniciar el servidor web de Apache** para poder empezar a utilizar PHP:

 

```bash
sudo service apache2 restart
```

 

 

## Curso rápido de PHP

 

El funcionamiento del **código PHP** es bastante sencillo, simplemente se escribe su código **encerrado entre “<?php”**y**“?>”**, por ejemplo:

 

```php
<?php echo 'Imprimir este texto'; ?>
```

 

Para probarlo **crea en “/var/www/html”** (con FileZilla por SFTP o con Vim; [como vimos en el artículo anterior](https://jarroba.com/usar-servidores-y-crear-una-web/)) **un fichero llamado “prueba.php”** (en la siguiente imagen se ven con FileZilla los [ficheros que creamos en el artículo anterior](https://jarroba.com/usar-servidores-y-crear-una-web/), para este artículo NO son necesarios, solo hace falta los que te señalo en rojo; dejo los antiguos por si continuas desde [el anterior artículo](https://jarroba.com/usar-servidores-y-crear-una-web/) y para que los puedas comparar):

 

![Captura de FileZilla con el fichero prueba.php resaltado en la carpeta /var/www/html del servidor](https://jarroba.com/wp-content/uploads/2019/09/Crear-un-nuevo-fichero-PHP-para-probar-www.Jarroba.png)

 

Y **escribiremos un código HTML que creará cinco párrafos de manera dinámica desde el PHP**(desde la parte del Servidor web) como el siguiente (en PHP si dejas abierto “{“ significa que engloba hasta el siguiente “}”, en este caso se repite el código HTML (<p>) que hay entre “{“ y “}” por pertenecer a un bucle “for”; en PHP las variables se escriben con el símbolo de dólar delante, como: “$i”):

 

```php
<!DOCTYPE html>
<html>

	<head>
		<meta charset="UTF-8">
	</head>

	<body>

		<?php for($i=1;$i<=5;$i++){ ?>
		<p>Párrafo <?php echo $i; ?></p> 
		<?php } ?>

	</body>

</html>
```

 

Te facilito tanto este código como todos los siguientes que aparecerán en este artículo **en la siguiente URL de Github**: [Ver en GitHub**Invarato/JarrobaWeb** / AvanzadoPHP](https://github.com/Invarato/JarrobaWeb/tree/master/AvanzadoPHP)

 

**Guarda el fichero** (**súbelo** al servidor si lo estás editando en local). Si **vamos a la URL de este fichero desde el navegador** veremos que el Servidor web de apache ha ejecutado el fichero PHP y nos ha devuelto al navegador un HTML con 5 párrafos simples (en mi caso escribiré: [http://85.208.20.119/prueba.php](http://85.208.20.119/prueba.php)):

 

![Captura del navegador con prueba.php mostrando cinco párrafos y su código fuente HTML generado por PHP](https://jarroba.com/wp-content/uploads/2019/09/Prueba-en-el-navegador-del-código-PHP-www.Jarroba.png)

 

Si pulsas con el botón derecho del ratón y seleccionas **“Ver código fuente de la página” podrás ver lo que realmente ha recibido tu navegador desde el servidor Web**. Que será el código HTML estático, pero que hemos creado dinámicamente (aunque eso el navegador nunca lo sabrá 😉 ).

 

 

## Prueba de LAMP

 

Crearemos un formulario HTML que llamaremos “miformulario.html” que recoja correos electrónicos, lo comprobaremos en cliente; y lo enviaremos al servidor al PHP “guardar_correo.php” donde también lo comprobaremos, si todo es correcto lo guardaremos en la base de datos y responderemos al cliente tanto si ha ido bien como si no.

 

**Crearemos en “/var/www/html” dos nuevos ficheros llamados “miformulario.html” y “guardar_correo.php”** (las extensiones HTML y PHP son importantes para que lo entienda correctamente el servidor web de Apache).

 

Para que no haya confusiones, antes te adelanté que cuando terminemos este artículo habremos creado los tres siguientes ficheros de la imagen (es muy importante que te fijes en la extensión php o html):

 

![Cliente FTP con la carpeta html del servidor y resaltados guardar_correo.php, miformulario.html y miformulario.php](https://jarroba.com/wp-content/uploads/2019/09/Probar-PHP-avanzado-www.Jarroba.png)

 

El HTML “**miformulario.html**” tendrá el siguiente código:

 

```xml
<!DOCTYPE html>
<html>

	<head>
		<meta charset="UTF-8">
		<title>Formulario</title>
	</head>

	<body>

		<form action="/guardar_correo.php" method="get">
		  Inserte su correo electrónico:
		  <br>
		  <input type="email" name="input_correo_electronico">
		  <br>
		  <input type="submit" value="Enviar">
		</form>

	</body>

</html>
```

 

Las etiquetas HTML:

 
- **<form>**: indica que se trata de un formulario, en **“action” pondremos** que cuando se pulse el botón de tipo “submit” se envía la información a esta **dirección** que será nuestro **“guardar_correo.php**”; en method le diremos que sea por “get”.
- **<input>**: crearemos dos, uno de tipo “email” (que nos facilitará la comprobación básica de correo electrónico sin tener que hacer nosotros nada; es decir, es como si hubiéramos escrito el código JavaScript pero sin escribirlo, ya lo trae el navegador, simplemente lo usamos). Y otro de tipo “submit” que será el botón enviar.

 

Si escribimos en el navegador nuestra IP pública y el fichero HTML (en mi caso: [http://85.208.20.119/miformulario.html](http://85.208.20.119/miformulario.html)) podremos ver lo que hemos creado con este código HTML:

 

![Captura del navegador con miformulario.html: formulario con campo de correo electrónico y botón Enviar](https://jarroba.com/wp-content/uploads/2019/09/Probar-a-enviar-en-formulario-datos-www.Jarroba.png)

 

Pero esto no hace nada, pues intenta enviar al servidor y el servidor web pasa completamente, ya que le falta el código para recoger este dato.

 

Pero sí podemos probar la comprobación desde el lado del navegador (cliente). Por ejemplo, **escribe algo que para nada sea un correo electrónico** (sin arroba “@”). Verás que **el navegador te muestra el mensaje de error** que comentamos antes:

 

![Captura del aviso del navegador al enviar «Jarroba.com»: falta el signo «@» en el correo](https://jarroba.com/wp-content/uploads/2019/09/Probar-a-enviar-en-formulario-datos-error-desde-cliente-www.Jarroba-1024x177.png)

 

Con el siguiente PHP “**guardar_correo.php**” conseguiremos recoger el dato y guardarlo en la base de datos (los métodos de los objetos en PHP se llaman con “->”: objeto->método() ):

 

```php
<?php

	// Recibir el dato por GET que hemos llamado en el <input> como "input_correo_electronico"
	$correo_recibido = $_GET["input_correo_electronico"];

	echo "El código PHP ha recibido: " . $correo_recibido;

	// Comprobar que sea un correo electrónico correcto desde el lado del servidor:
	$patron = "/[A-Za-z]+@[a-z]+\.[a-z]+/";
	$esCoincidente = preg_match($patron, $correo_recibido);

	if (!$esCoincidente) {
	    exit("<br/>No es un correo electrónico válido: " . $correo_recibido);
	}

	// Conectarse a la base de datos para guardar el dato
	$nombreDelServidor = "127.0.0.1";   // "localhost"
	$nombreDeUsuario = "MiUsuarioDeMiBaseDeDeatos";
	$contrasenia = "grY3h5%5dDsJJbdXj";
	$nombreDeLaBaseDeDatos = "MiBaseDeDatos";

	echo '<br/>Abriendo conexión con la base de datos MySQL';
 	$conexion_bd = new mysqli($nombreDelServidor, $nombreDeUsuario, $contrasenia, $nombreDeLaBaseDeDatos);

 	echo '<br/>Comprobando conexión con la base de datos MySQL';
	if ($conexion_bd->connect_error) {
	    exit('No pudo conectarse: ' . $conexion_bd->connect_error);
	}
	
	echo '<br/>Creando consulta de INSERT para la base de datos MySQL';

	$sentencia_sql = $conexion_bd->prepare("INSERT INTO MiTabla (correo_electronico) VALUES (?)");
	$sentencia_sql->bind_param('s', $correo_recibido);

	echo '<br/>Insertando en la base de datos MySQL';
	$sentencia_sql->execute();

	echo '<br/>Cerrando conexión con la base de datos MySQL';
	$conexion_bd->close();

?>
```

 

Este código PHP hace lo siguiente:

 
- Recoge el dato que se envíe con el **método “get”** con: $_GET[«input_correo_electronico»]
- Con “preg_match” realizaremos una **comprobación de** si **lo que ha llegado al servidor**es realmente un correo electrónico (aquí la comprobación será más completa que en el lado del cliente).
- Crearemos la **conexión a la base de datos** con “mysqli” (aquí tendrás que poner tus datos, sustituyendo los míos de ejemplo; por cierto, nunca subas las credenciales de tu base de datos a ningún sitio, aquí yo lo hago para mostrarte un ejemplo completo; evidentemente cuando estés leyendo este artículo mi base de datos de ejemplo con estas credenciales ya no existirá)
- Con “prepare” crearemos la **consulta SQL** de inserción (igual que mostramos antes; pero en donde se vayan a poner el valor que venga del formulario pondremos una interrogación “?”)
- Con “bind_param” cuya letra “s” indicará que el valor que le pasemos es un texto. Esto nos **comprobará que no nos hagan una inyección de SQL**
- Con “execute” **ejecutaremos la consulta SQL** contra el servidor de base de datos MySQL.
- Y siempre es importante **cerrar la conexión con la base de datos** al final con “close”

 

Guarda los dos ficheros y súbelos. Vamos a probar con algo que pase la validación de JavaScript pero no la del servidor. Escribamos algo con arroba “@” pero sin punto después de esta arroba. Veremos que no pasa la validación en el lado del servidor.

 

![Captura del formulario con «Jarroba.com@gmail» y la respuesta del servidor PHP: no es un correo electrónico válido](https://jarroba.com/wp-content/uploads/2019/09/Probar-a-enviar-en-formulario-erroneos-pero-que-pase-el-filtro-en-cliente-y-de-error-en-servidor-www.Jarroba-1024x140.png)

 

Al pulsar el botón enviar y al procesarse en el lado del Servidor, como puedes comprobar en la barra de direcciones el navegador te ha redirigido al fichero PHP y aquí se muestra su resultado (existen trucos para que no cambie de página web y se ejecute el PHP en segundo plano mientras se permanece en la misma ventana; aquí quiero que veas claramente cada una de las partes implicadas por separado).

 

Para volver a probar a insertar otro correo, puedes pulsar el botón de atrás del navegador.

 

Si escribes un correo electrónico correcto verás que sí pasa la validación del servidor y se guarda correctamente en la base de datos:

 

![Captura del envío de un correo válido y la respuesta PHP con los pasos de conexión e inserción en MySQL](https://jarroba.com/wp-content/uploads/2019/09/Probar-a-enviar-en-formulario-con-datos-correctos-www.Jarroba-1024x158.png)

 

**Nota sobre la seguridad:** No envíes información confidencial o privada, pues estás enviándola en claro por Internet (desde tu navegador hasta tu servidor viajará sin cifrar) y cualquiera podría leerla; así que para jugar y hacer pruebas vale, pero si quieres algo más serio tendrás que poner un HTTPS con su certificado.

 

En la consola de MySQL puedes ver que realmente se ha insertado en nuestra tabla con el mismo SELECT que vimos antes:

 

```sql
SELECT * FROM MiTabla;
```

 

![Captura de la consola MySQL con SELECT * FROM MiTabla; que muestra el correo Jarroba@gmail.com guardado](https://jarroba.com/wp-content/uploads/2019/09/Probar-que-la-base-de-datos-ha-recibido-los-datos-correctos-del-formulario-www.Jarroba.png)

 

Podríamos terminar con esto, pero quería dejarte de regalo **la consulta de los datos y mostrarte la combinación de la base de datos con el HTML**. Así que vamos a crear otro PHP que se llamará parecido que antes, pero cambiaremos la extensión de “.html” a “.php” quedando: “miformulario.php” con el siguiente código (solo hemos añadido la parte de PHP respecto al HTML anterior):

 

```php
<!DOCTYPE html>
<html>

	<head>
		<meta charset="UTF-8">
		<title>Formulario</title>
	</head>

	<body>

		<form action="/guardar_correo.php" method="get">
		  Inserte su correo electrónico:
		  <br>
		  <input type="email" name="input_correo_electronico">
		  <br>
		  <input type="submit" value="Enviar">
		</form>

		<h2>Correos guardados:</h2>

		<?php
			$nombreDelServidor = "127.0.0.1";
			$nombreDeUsuario = "MiUsuarioDeMiBaseDeDeatos";
			$contrasenia = "grY3h5%5dDsJJbdXj";
			$nombreDeLaBaseDeDatos = "MiBaseDeDatos";

		 	$conexion_bd = new mysqli($nombreDelServidor, $nombreDeUsuario, $contrasenia, $nombreDeLaBaseDeDatos);
			if ($conexion_bd->connect_error) {
			    exit('No pudo conectarse: ' . $conexion_bd->connect_error);
			}
			
			$sentencia_sql = $conexion_bd->prepare("SELECT correo_electronico FROM MiTabla");
			$sentencia_sql->execute();

			$resultado = $sentencia_sql->get_result();
			while ($fila = $resultado->fetch_assoc()) {
			    echo '<br/> * ' . $fila["correo_electronico"];
			}
			$resultado->free();

			$conexion_bd->close();
		?>

	</body>

</html>
```

 

Este PHP hace lo mismo que antes, se conecta con nuestros datos a la base de datos MySQL pero para realizar la consulta hacemos:

 
- En “prepare” la **consulta** SELECT **y** la **ejecutamos** con “execute”
- **Obtenemos los resultados** con “get_result”
- En un **bucle vamos obteniendo fila a fila** con “fetch_assoc()”
- Y **liberamos tanto el resultado** con “free” **como la conexión** con “close”.

 

Prueba a insertar varios correos y verás que va apareciendo el listado completo justo debajo (cada vez que mandes un correo pulsa el botón de atrás del navegador para enviar otro; sino ves que aparecen los correos debajo puede que tengas que refrescar el navegador para que se vuelva a llamar al servidor y se procese el PHP):

 

![Captura de miformulario.php con el formulario y debajo la lista de correos guardados en la base de datos](https://jarroba.com/wp-content/uploads/2019/09/Probar-que-la-base-de-datos-ha-recibido-los-datos-correctos-del-formulario-con-Select-de-respuesta-www.Jarroba.png)

 

Si tienes más curiosidad sobre PHP existe un tutorial en la página web oficial en español en: [Un tutorial sencillo (Manual de PHP)](https://www.php.net/manual/es/tutorial.php)

 

También puedes echar un vistazo a todo lo que ofrece PHP en [Alphabetical (Manual de PHP)](https://www.php.net/manual/en/extensions.alphabetical.php)

 

Y hasta aquí te dejo para que crees todo lo que te propongas, que puedas utilizar cualquier servidor Software o Hardware sin que sea un problema para ti. Hay que leerse sus manuales, pero el camino es parecido entendido este artículo. Por lo que desde ahora en adelante, en cuanto a clientes y servidores, podrás realizar con éxito muchísimos desarrollos de una manera ágil con todo lo que aquí has aprendido 🙂

 

 

## Bibliografía

 

- [Welcome! (The Apache HTTP Server Project)](http://httpd.apache.org/)
- [PHP (php.net)](https://www.php.net/)
- [MySQL](https://www.mysql.com/)
- [JavaScript (MDN)](https://developer.mozilla.org/es/docs/Web/JavaScript)
- [Cascading Style Sheets (W3C)](https://www.w3.org/Style/CSS/)
- [LAMP (Wikipedia)](https://es.wikipedia.org/wiki/LAMP)
- [clouding.io/kb](https://clouding.io/kb/)