MySQL: Primeros pasos

Cómo empezar con MySQL

👋 ¡Bienvenido a la documentación de Stackhero!

Stackhero ofrece una solución MySQL cloud lista para usar que proporciona una serie de beneficios, incluyendo:

  • Conexiones y transferencias ilimitadas.
  • Interfaz web phpMyAdmin incluida.
  • Actualizaciones sin esfuerzo con solo un clic.
  • Rendimiento óptimo y seguridad robusta gracias a una VM privada y dedicada.

Ahorre tiempo y simplifique su vida: ¡solo toma 5 minutos probar la solución de MySQL cloud hosting de Stackhero!

URLs de MySQL

Si desea una forma rápida de conectarse a su servicio MySQL, puede considerar utilizar el formato de URL de MySQL, siempre que su driver lo soporte:

mysql://root:<ROOT_PASSWORD>@<XXXXXX>.stackhero-network.com:<PORT>/root?useSSL=true&requireSSL=true

Si trabaja con Ruby, el formato de URL es ligeramente diferente:

mysql2://root:<ROOT_PASSWORD>@<XXXXXX>.stackhero-network.com:<PORT>/root?reconnect=true&useSSL=true&requireSSL=true

Usar MySQL con PHP

MySQLi (estilo orientado a objetos)

Aquí tiene un ejemplo de conexión a MySQL usando la extensión MySQLi de PHP en estilo orientado a objetos:

<?php

$hostname = '<XXXXXX>.stackhero-network.com';
$port = '<PORT>';
$user = 'root';
$password = '<ROOT_PASSWORD>';
$database = 'root'; // Aunque este ejemplo utiliza la base de datos "root", es recomendable crear una base de datos y un usuario dedicados para su aplicación a través de phpMyAdmin.

$mysqli = mysqli_init();
$mysqliConnected = $mysqli->real_connect($hostname, $user, $password, $database, $port, NULL, MYSQLI_CLIENT_SSL);
if (!$mysqliConnected) {
  die("Error de conexión: " . $mysqli->connect_error);
}

echo 'Conexión exitosa... ' . $mysqli->host_info . "\n";

$mysqli->close();

?>

MySQLi (estilo procedural)

Si prefiere código procedural, así puede conectarse usando MySQLi en estilo procedural:

<?php

$hostname = '<XXXXXX>.stackhero-network.com';
$port = '<PORT>';
$user = 'root';
$password = '<ROOT_PASSWORD>';
$database = 'root'; // Para mayor seguridad, cree una base de datos y un usuario dedicados en phpMyAdmin en lugar de usar "root".

$mysqli = mysqli_init();
$mysqliConnected = mysqli_real_connect($mysqli, $hostname, $user, $password, $database, $port, NULL, MYSQLI_CLIENT_SSL);
if (!$mysqliConnected) {
  die("Error de conexión: " . mysqli_connect_error($mysqli));
}

echo 'Éxito: ' . mysqli_get_host_info($mysqli) . "\n";

mysqli_close($mysqli);

?>

PDO

Si prefiere PDO para el acceso a la base de datos, aquí tiene un ejemplo de configuración de la conexión:

<?php

$hostname = '<XXXXXX>.stackhero-network.com';
$port = '<PORT>';
$user = 'root';
$password = '<ROOT_PASSWORD>';
$database = 'root'; // Es recomendable crear una base de datos y un usuario dedicados para su aplicación.

$dsn = "mysql:host=$hostname;port=$port;dbname=$database";

$options = array(
  // Si aparecen errores relacionados con SSL al conectar, asegúrese de que su sistema tenga instalados los certificados CA adecuados (ver más abajo).
  PDO::MYSQL_ATTR_SSL_CAPATH => '/etc/ssl/certs/',
  // PDO::MYSQL_ATTR_SSL_CA => 'isrgrootx1.pem',
  PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
);

$pdo = new PDO($dsn, $user, $password, $options);

$stm = $pdo->query("SELECT VERSION()");
$version = $stm->fetch();

echo "Está conectado a una base de datos con la versión " . $version[0] . "\n";

?>

Resolución de problemas: SSL operation failed with code 1

Si ve un error como este:

Uncaught PDOException: PDO::__construct(): SSL operation failed with code 1. OpenSSL Error messages: error:0A000086:SSL routines::certificate verify failed

Esto probablemente se debe a que su sistema no tiene certificados CA en /etc/ssl/certs/.

Si tiene acceso al sistema donde se ejecuta su código PHP, puede añadir los certificados así:

  1. En Ubuntu/Debian: sudo apt-get install ca-certificates
  2. En Alpine Linux: apk add ca-certificates

Si no tiene acceso directo, puede añadir el certificado manualmente:

  1. Descargue el certificado: https://letsencrypt.org/certs/isrgrootx1.pem
  2. Coloque el archivo isrgrootx1.pem en su proyecto PHP.
  3. Comente la línea PDO::MYSQL_ATTR_SSL_CAPATH => '/etc/ssl/certs/'
  4. Descomente la línea PDO::MYSQL_ATTR_SSL_CA => 'isrgrootx1.pem'

Resolución: errores de constantes indefinidas con PDO

Si ve errores como:

Fatal error: Uncaught Error: Undefined constant PDO::MYSQL_ATTR_SSL_CAPATH

o mensajes similares, esto indica que PDO se instaló sin soporte para MySQL.

  1. En Ubuntu/Debian

Puede añadir la extensión necesaria ejecutando:

sudo apt-get install php-mysql
  1. En Docker

Si utiliza Docker, asegúrese de que el soporte para MySQL esté incluido durante la construcción. Puede añadir esto a su Dockerfile:

RUN docker-php-ext-install pdo pdo_mysql


### Usar MySQL con Symfony y Doctrine

Si trabaja con Symfony y Doctrine, puede configurar su conexión así:

1. Edite su archivo `.env` y defina la variable `DATABASE_URL`:

DATABASE_URL="mysql://<USER>:<PASSWORD>@<XXXXXX>.stackhero-network.com:<PORT>/<DATABASE>"


1. Después, en `config/packages/doctrine.yaml`, configure el driver y las opciones:

```yaml
doctrine:
    dbal:
        url: '%env(resolve:DATABASE_URL)%'
        driver: 'pdo_mysql'
        options:
            # PDO::MYSQL_ATTR_SSL_CAPATH
            1010: '/etc/ssl/certs'
            # PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT
            1014: true

Resolución de problemas: SSL operation failed with code 1

Si encuentra un error como:

Uncaught PDOException: PDO::__construct(): SSL operation failed with code 1. OpenSSL Error messages: error:0A000086:SSL routines::certificate verify failed

Esto probablemente se debe a que el directorio /etc/ssl/certs/ no contiene los certificados CA.

Si puede acceder al sistema, puede instalarlos así:

  1. En Ubuntu/Debian: sudo apt-get install ca-certificates
  2. En Alpine Linux: apk add ca-certificates

Si no tiene acceso directo, puede añadir el certificado manualmente:

  1. Descargue: https://letsencrypt.org/certs/isrgrootx1.pem
  2. Coloque isrgrootx1.pem en su proyecto Symfony.
  3. Actualice config/packages/doctrine.yaml:
doctrine:
    dbal:
        url: '%env(resolve:DATABASE_URL)%'
        driver: 'pdo_mysql'
        options:
            # PDO::MYSQL_ATTR_SSL_CA
            1009: 'isrgrootx1.pem'
            # PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT
            1014: true

Usar MySQL con Laravel

Para configurar MySQL en Laravel, abra config/database.php y actualice la sección de MySQL:

'mysql' => [
  'driver' => 'mysql',
  'host' => env('STACKHERO_MYSQL_HOST'),
  'port' => env('STACKHERO_MYSQL_PORT'),
  'username' => env('STACKHERO_MYSQL_USER'),
  'password' => env('STACKHERO_MYSQL_PASSWORD'),
  'database' => env('STACKHERO_MYSQL_USER'),
  'charset' => 'utf8mb4',
  'collation' => 'utf8mb4_unicode_ci',
  'prefix' => '',
  'prefix_indexes' => true,
  'strict' => true,
  'engine' => null,
  'sslmode' => 'require',
  'options' => extension_loaded('pdo_mysql')
    ? array_filter([
      // Para errores SSL, consulte la sección de resolución de problemas anterior.
      PDO::MYSQL_ATTR_SSL_CAPATH => '/etc/ssl/certs/',
      // PDO::MYSQL_ATTR_SSL_CA => 'isrgrootx1.pem',
      PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
    ])
    : [],
],

Usar MySQL con PHP CodeIgniter

En el archivo de configuración database.php, puede añadir:

$db['default'] = array(
  'hostname' => getenv('STACKHERO_MYSQL_HOST'),
  'port'     => getenv('STACKHERO_MYSQL_PORT'),
  'username' => getenv('STACKHERO_MYSQL_USER'),
  'password' => getenv('STACKHERO_MYSQL_PASSWORD'),
  'database' => getenv('STACKHERO_MYSQL_USER'), // Por convención, el nombre de la base de datos coincide con el usuario.
  'dbdriver' => 'mysqli',
  'dbprefix' => '',
  'pconnect' => true,
  'char_set' => 'utf8',
  'dbcollat' => 'utf8_general_ci',
  'encrypt'  => array() // Importante: habilite el cifrado TLS
);

Conexión usando variables de entorno en PHP

Por lo general, es más seguro evitar almacenar sus credenciales de base de datos en el código. En su lugar, puede utilizar variables de entorno. Así puede recuperarlas:

$hostname = getenv('STACKHERO_MYSQL_HOST');
$port = getenv('STACKHERO_MYSQL_PORT');
$user = getenv('STACKHERO_MYSQL_USER');
$password = getenv('STACKHERO_MYSQL_PASSWORD');
$database = getenv('STACKHERO_MYSQL_USER'); // Por convención, el nombre de la base de datos coincide con el usuario.

Usar MySQL con WordPress

Conectar WordPress a Stackhero para MySQL es sencillo. Solo tiene que editar su archivo wp-config.php así:

define('DB_HOST', '<XXXXXX>.stackhero-network.com');
define('DB_PORT', '<PORT>');
define('DB_NAME', 'root');
define('DB_USER', 'root');
define('DB_PASSWORD', '<yourPassword>');

// Habilite el cifrado TLS (también conocido como SSL)
define('MYSQL_CLIENT_FLAGS', MYSQLI_CLIENT_SSL);

El paso clave aquí es habilitar el cifrado TLS (SSL). Sin esto, la conexión no funcionará correctamente.

Usar MySQL con Node.js

Protocolo MySQL X (paquete xdevapi)

Para utilizar el protocolo MySQL X, puede instalar el paquete oficial xdevapi:

npm install @mysql/xdevapi

Aquí tiene un ejemplo de script:

const mysqlx = require('@mysql/xdevapi');

(async () => {
  // Conectar a MySQL usando el protocolo MySQL X
  const session = await mysqlx.getSession({
    host: '<XXXXXX>.stackhero-network.com',
    port: '<PORT>',
    user: 'root',
    password: '<ROOT_PASSWORD>'
  });

  // Crear el esquema (base de datos) si no existe
  const schemaExists = await session.getSchema('stackherotest').existsInDatabase();
  if (!schemaExists) {
    await session.createSchema('stackherotest');
  }

  // Crear la tabla 'users' si no existe
  const tableExists = await session
    .getSchema('stackherotest')
    .getTable('users')
    .existsInDatabase();
  if (!tableExists) {
    await session
      .sql('CREATE TABLE `stackherotest`.`users` '
        + '('
        + '`userId` INT UNSIGNED NOT NULL,'
        + '`name` VARCHAR(128) NOT NULL,'
        + '`address` TEXT NOT NULL,'
        + '`email` VARCHAR(265) NOT NULL'
        + ') '
        + 'ENGINE = InnoDB;')
      .execute();
  }

  // Insertar un usuario de ejemplo
  await session
    .getSchema('stackherotest')
    .getTable('users')
    .insert('userId', 'name', 'address', 'email')
    .values(
      Math.round(Math.random() * 100000),
      'User name',
      'User address',
      '[email protected]'
    )
    .execute();

  // Contar el número de usuarios
  const usersCount = await session
    .getSchema('stackherotest')
    .getTable('users')
    .count();

  console.log(`Ahora hay ${usersCount} entradas en la tabla "users"`);

  // Cerrar la conexión
  await session.close();

})().catch(error => {
  console.error('');
  console.error('¡Ha ocurrido un error!');
  console.error(error);
  process.exit(1);
});

Protocolo MySQL clásico (paquete mysql2)

Si prefiere el protocolo clásico, puede usar el paquete mysql2 con soporte para promesas. Puede instalarlo con:

npm install mysql2

Ejemplo de uso:

const mysql = require('mysql2/promise');

(async () => {
  const db = await mysql.createConnection({
    host: '<XXXXXX>.stackhero-network.com',
    port: '<PORT>',
    user: 'root',
    password: '<ROOT_PASSWORD>'
  });

  // Crear la base de datos si es necesario
  await db.query('CREATE DATABASE IF NOT EXISTS stackherotest');

  // Crear la tabla si es necesario
  await db.query('CREATE TABLE IF NOT EXISTS `stackherotest`.`users` '
    + '('
    + '`userId` INT UNSIGNED NOT NULL,'
    + '`name` VARCHAR(128) NOT NULL,'
    + '`address` TEXT NOT NULL,'
    + '`email` VARCHAR(265) NOT NULL'
    + ') '
    + 'ENGINE = InnoDB;');

  // Insertar un usuario de ejemplo
  await db.query(
    'INSERT INTO `stackherotest`.`users` (`userId`, `name`, `address`, `email`) VALUES ?',
    [
      [
        Math.round(Math.random() * 100000),
        'User name',
        'User address',
        '[email protected]'
      ]
    ]
  );

  // Contar usuarios
  const [ usersCount ] = await db.query('SELECT COUNT(*) AS `cpt` FROM `stackherotest`.`users`');
  console.log(`Ahora hay ${usersCount[0].cpt} entradas en la tabla "users"`);

  // Cerrar la conexión
  await db.end();

})().catch(error => {
  console.error('');
  console.error('¡Ha ocurrido un error!');
  console.error(error);
  process.exit(1);
});

Usar MySQL con Node.js, NestJS o TypeORM

Para conectarse desde Node.js, NestJS o TypeORM, puede añadir la opción ssl como se muestra a continuación:

TypeOrmModule.forRoot({
  type: 'mysql',
  host: '<XXXXXX>.stackhero-network.com',
  port: <PORT>,
  username: 'root',
  password: '<ROOT_PASSWORD>',
  database: 'root',
  entities: [],
  synchronize: true,
  ssl: {}
});

Usar MySQL con Prisma

Si utiliza Prisma, añadir la opción sslaccept=strict ayuda a garantizar conexiones cifradas. Aquí tiene un ejemplo de configuración:

datasource db {
  provider = "mysql"
  url = "mysql://root:<ROOT_PASSWORD>@<XXXXXX>.stackhero-network.com:<PORT>/root?sslaccept=strict"
}

Usar MySQL con Django

Si aún no ha instalado el módulo mysqlclient, puede hacerlo con:

pip install mysqlclient

Si durante la instalación aparece el error Exception: Can not find valid pkg-config name, puede que necesite añadir el paquete libmysqlclient. En Ubuntu/Debian, puede hacerlo con: apt-get update && apt-get install --no-install-recommends -y libmysqlclient-dev

Inicialmente, puede probar la conexión almacenando la contraseña directamente en su archivo settings.py. Sin embargo, para mayor seguridad a largo plazo, es mejor usar variables de entorno (ver más abajo).

Edite su settings.py así:

DATABASES = {
  'default': {
    'ENGINE': 'django.db.backends.mysql',
    'HOST': '<XXXXXX>.stackhero-network.com',
    'PORT': '<PORT>',
    'OPTIONS': {
      'ssl_mode': 'REQUIRED',
    },
    'NAME': 'root',
    'USER': 'root',
    'PASSWORD': '<ROOT_PASSWORD>'
  }
}

Tenga en cuenta: este ejemplo es solo para pruebas y no se recomienda para entornos de producción.

Una vez haya comprobado que la conexión funciona, puede pasar a un enfoque más seguro usando django-environ para gestionar variables de entorno.

Primero, instale el paquete:

pip install django-environ

Después, actualice su settings.py:

import environ
env = environ.Env()
environ.Env.read_env()

DATABASES = {
  'default': {
    'ENGINE': 'django.db.backends.mysql',
    'HOST': env('STACKHERO_MYSQL_HOST'),
    'PORT': env('STACKHERO_MYSQL_PORT'),
    'OPTIONS': {
      'ssl_mode': 'REQUIRED',
    },
    'NAME': 'root',
    'USER': 'root',
    'PASSWORD': env('STACKHERO_MYSQL_ROOT_PASSWORD')
  }
}

Cree o edite el archivo .env en el mismo directorio que settings.py y añada:

STACKHERO_MYSQL_HOST=<XXXXXX>.stackhero-network.com
STACKHERO_MYSQL_PORT=<PORT>
STACKHERO_MYSQL_ROOT_PASSWORD=<ROOT_PASSWORD>

Por último, para mantener sus credenciales seguras, puede añadir .env a su archivo .gitignore:

echo ".env" >> .gitignore

Conectar MySQL con Java/Spring

Para conectar su aplicación Spring, puede definir la variable de entorno SPRING_DATASOURCE_URL con la URL de su base de datos, asegurándose de anteponer jdbc::

SPRING_DATASOURCE_URL=jdbc:mysql://root:<ROOT_PASSWORD>@<XXXXXX>.stackhero-network.com:<PORT>/root?useSSL=true&requireSSL=true

Conectar MySQL con Groovy/Grails

Aquí tiene un ejemplo de configuración de su aplicación Grails para conectarse a MySQL:

dataSource {
  pooled = true
  driverClassName = "com.mysql.cj.jdbc.Driver"
  dialect = org.hibernate.dialect.MySQL8Dialect
  // Propiedades específicas de SSL
  properties {
    useSSL = true
    requireSSL = true
    verifyServerCertificate = true
    sslMode = "REQUIRED"
  }
}

environments {
  production {
    dataSource {
      dbCreate = "none"
      url = "jdbc:mysql://" + System.env.STACKHERO_MYSQL_HOST + ":" + System.env.STACKHERO_MYSQL_PORT + "/root?useSSL=true&requireSSL=true&verifyServerCertificate=true&sslMode=required" // Puede sustituir "/root" por la base de datos que prefiera.
      username = "root" // Es recomendable crear un usuario dedicado para su aplicación.
      password = System.env.STACKHERO_MYSQL_ROOT_PASSWORD
      properties {
        maxActive = 50
        minEvictableIdleTimeMillis = 1800000
        timeBetweenEvictionRunsMillis = 1800000
        numTestsPerEvictionRun = 3
        testOnBorrow = true
        testWhileIdle = true
        testOnReturn = false
        validationQuery = "SELECT 1"
      }
    }
  }
}

Crear un usuario en MySQL usando phpMyAdmin

Para mejorar la seguridad, es recomendable crear un usuario dedicado para su aplicación en lugar de utilizar el usuario "root". Puede hacerlo fácilmente con phpMyAdmin:

  1. En phpMyAdmin, seleccione Cuentas de usuario en el menú superior.

  2. Haga clic en Añadir cuenta de usuario.

  3. Complete el formulario de creación de usuario:

    • Introduzca un nombre de cuenta (normalmente el nombre de su aplicación)
    • Haga clic en Generar contraseña para obtener una contraseña segura y cópiela
    • Seleccione Crear base de datos con el mismo nombre y otorgar todos los privilegios

Una vez envíe el formulario, dispondrá de un nuevo usuario y una base de datos dedicada que comparte el mismo nombre que su usuario.

Otros artículos para MySQL

  1. Introducción
    Introducción a MySQL
  2. Uso avanzado
    Cómo configurar, optimizar, exportar o importar datos de MySQL
  3. Configurar las GUIs
    Cómo conectar interfaces gráficas a MySQL
  4. Solución de problemas
    Problemas comunes y soluciones para MySQL
  5. Workbench
    Cómo configurar MySQL Workbench