MySQL: Premiers pas

Comment débuter avec MySQL

👋 Bienvenue sur la documentation de Stackhero !

Stackhero propose une solution MySQL cloud prête à l'emploi qui offre de nombreux avantages, notamment :

  • Connexions et transferts illimités.
  • Interface web phpMyAdmin incluse.
  • Mises à jour faciles en un clic.
  • Performance optimale et sécurité robuste grâce à une VM privée et dédiée.

Gagnez du temps et simplifiez-vous la vie : il ne faut que 5 minutes pour essayer la solution MySQL cloud hosting de Stackhero !

URLs MySQL

Si vous souhaitez une méthode rapide pour vous connecter à votre service MySQL, vous pouvez utiliser le format d'URL MySQL, à condition que votre driver le prenne en charge :

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

Si vous travaillez avec Ruby, le format d'URL est légèrement différent :

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

Utiliser MySQL avec PHP

MySQLi (style orienté objet)

Voici un exemple de connexion à MySQL en PHP avec l'extension MySQLi en style orienté objet :

<?php

$hostname = '<XXXXXX>.stackhero-network.com';
$port = '<PORT>';
$user = 'root';
$password = '<ROOT_PASSWORD>';
$database = 'root'; // Cet exemple utilise la base "root", mais il est recommandé de créer une base et un utilisateur dédiés pour votre application via phpMyAdmin.

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

echo 'Connexion réussie... ' . $mysqli->host_info . "\n";

$mysqli->close();

?>

MySQLi (style procédural)

Si vous préférez le code procédural, voici comment vous connecter avec MySQLi en style procédural :

<?php

$hostname = '<XXXXXX>.stackhero-network.com';
$port = '<PORT>';
$user = 'root';
$password = '<ROOT_PASSWORD>';
$database = 'root'; // Pour une sécurité optimale, créez une base et un utilisateur dédiés dans phpMyAdmin au lieu d'utiliser "root".

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

echo 'Succès : ' . mysqli_get_host_info($mysqli) . "\n";

mysqli_close($mysqli);

?>

PDO

Si vous préférez utiliser PDO pour accéder à la base de données, voici un exemple de connexion :

<?php

$hostname = '<XXXXXX>.stackhero-network.com';
$port = '<PORT>';
$user = 'root';
$password = '<ROOT_PASSWORD>';
$database = 'root'; // Il est préférable de créer une base et un utilisateur dédiés pour votre application.

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

$options = array(
  // Si vous rencontrez des erreurs liées au SSL lors de la connexion, vérifiez que votre système dispose des bons certificats CA installés (voir ci-dessous).
  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 "Vous êtes connecté à une base de données en version " . $version[0] . "\n";

?>

Dépannage : SSL operation failed with code 1

Si vous voyez une erreur comme :

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

Cela signifie probablement que votre système ne dispose pas des certificats CA dans /etc/ssl/certs/.

Si vous avez accès au système où s'exécute votre code PHP, vous pouvez ajouter les certificats ainsi :

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

Si vous n'avez pas d'accès direct, vous pouvez ajouter le certificat manuellement :

  1. Téléchargez le certificat : https://letsencrypt.org/certs/isrgrootx1.pem
  2. Placez le fichier isrgrootx1.pem dans votre projet PHP.
  3. Commentez la ligne PDO::MYSQL_ATTR_SSL_CAPATH => '/etc/ssl/certs/'
  4. Décommentez la ligne PDO::MYSQL_ATTR_SSL_CA => 'isrgrootx1.pem'

Résolution : erreurs de constantes non définies avec PDO

Si vous voyez des erreurs comme :

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

ou des messages similaires, cela indique que PDO a été installé sans le support MySQL.

  1. Sur Ubuntu/Debian

Vous pouvez ajouter l'extension requise avec :

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

Si vous utilisez Docker, assurez-vous que le support MySQL est inclus lors du build. Ajoutez ceci dans votre Dockerfile :

RUN docker-php-ext-install pdo pdo_mysql


### Utiliser MySQL avec Symfony et Doctrine

Si vous travaillez avec Symfony et Doctrine, vous pouvez configurer votre connexion ainsi :

1. Modifiez votre fichier `.env` et définissez la variable `DATABASE_URL` :

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


1. Ensuite, dans `config/packages/doctrine.yaml`, définissez le driver et les options :

```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

Dépannage : SSL operation failed with code 1

Si vous rencontrez une erreur comme :

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

Cela signifie probablement que le dossier /etc/ssl/certs/ ne contient pas les certificats CA.

Si vous avez accès au système, vous pouvez les installer ainsi :

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

Si vous n'avez pas d'accès direct, vous pouvez ajouter le certificat manuellement :

  1. Téléchargez : https://letsencrypt.org/certs/isrgrootx1.pem
  2. Placez isrgrootx1.pem dans votre projet Symfony.
  3. Mettez à jour 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

Utiliser MySQL avec Laravel

Pour configurer MySQL dans Laravel, ouvrez config/database.php et modifiez la section 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([
      // Pour les erreurs SSL, voir le dépannage ci-dessus.
      PDO::MYSQL_ATTR_SSL_CAPATH => '/etc/ssl/certs/',
      // PDO::MYSQL_ATTR_SSL_CA => 'isrgrootx1.pem',
      PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
    ])
    : [],
],

Utiliser MySQL avec PHP CodeIgniter

Dans le fichier de configuration database.php, vous pouvez ajouter :

$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'), // Par convention, le nom de la base correspond à l'utilisateur.
  'dbdriver' => 'mysqli',
  'dbprefix' => '',
  'pconnect' => true,
  'char_set' => 'utf8',
  'dbcollat' => 'utf8_general_ci',
  'encrypt'  => array() // Important : activez le chiffrement TLS
);

Connexion avec des variables d'environnement en PHP

Il est généralement plus sûr d'éviter de stocker vos identifiants de base de données dans votre code. Vous pouvez utiliser des variables d'environnement. Voici comment les récupérer :

$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'); // Par convention, le nom de la base correspond à l'utilisateur.

Utiliser MySQL avec WordPress

Connecter WordPress à Stackhero pour MySQL est simple. Il suffit de modifier votre fichier wp-config.php comme ceci :

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

// Activez le chiffrement TLS (aussi appelé SSL)
define('MYSQL_CLIENT_FLAGS', MYSQLI_CLIENT_SSL);

L'étape clé ici est d'activer le chiffrement TLS (SSL). Sans cela, votre connexion ne fonctionnera pas correctement.

Utiliser MySQL avec Node.js

Protocole MySQL X (package xdevapi)

Pour utiliser le protocole MySQL X, installez le package officiel xdevapi :

npm install @mysql/xdevapi

Voici un exemple de script :

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

(async () => {
  // Connexion à MySQL avec le protocole MySQL X
  const session = await mysqlx.getSession({
    host: '<XXXXXX>.stackhero-network.com',
    port: '<PORT>',
    user: 'root',
    password: '<ROOT_PASSWORD>'
  });

  // Crée le schéma (base) s'il n'existe pas
  const schemaExists = await session.getSchema('stackherotest').existsInDatabase();
  if (!schemaExists) {
    await session.createSchema('stackherotest');
  }

  // Crée la table 'users' si elle n'existe pas
  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();
  }

  // Insère un utilisateur exemple
  await session
    .getSchema('stackherotest')
    .getTable('users')
    .insert('userId', 'name', 'address', 'email')
    .values(
      Math.round(Math.random() * 100000),
      'User name',
      'User address',
      '[email protected]'
    )
    .execute();

  // Compte le nombre d'utilisateurs
  const usersCount = await session
    .getSchema('stackherotest')
    .getTable('users')
    .count();

  console.log(`Il y a maintenant ${usersCount} entrées dans la table "users"`);

  // Ferme la connexion
  await session.close();

})().catch(error => {
  console.error('');
  console.error('Une erreur est survenue !');
  console.error(error);
  process.exit(1);
});

Protocole MySQL classique (package mysql2)

Si vous préférez le protocole classique, vous pouvez utiliser le package mysql2 avec le support des promesses. Installez-le avec :

npm install mysql2

Exemple d'utilisation :

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

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

  // Crée la base si besoin
  await db.query('CREATE DATABASE IF NOT EXISTS stackherotest');

  // Crée la table si besoin
  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;');

  // Insère un utilisateur exemple
  await db.query(
    'INSERT INTO `stackherotest`.`users` (`userId`, `name`, `address`, `email`) VALUES ?',
    [
      [
        Math.round(Math.random() * 100000),
        'User name',
        'User address',
        '[email protected]'
      ]
    ]
  );

  // Compte les utilisateurs
  const [ usersCount ] = await db.query('SELECT COUNT(*) AS `cpt` FROM `stackherotest`.`users`');
  console.log(`Il y a maintenant ${usersCount[0].cpt} entrées dans la table "users"`);

  // Ferme la connexion
  await db.end();

})().catch(error => {
  console.error('');
  console.error('Une erreur est survenue !');
  console.error(error);
  process.exit(1);
});

Utiliser MySQL avec Node.js, NestJS ou TypeORM

Pour vous connecter depuis Node.js, NestJS ou TypeORM, vous pouvez ajouter l'option ssl comme ci-dessous :

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

Utiliser MySQL avec Prisma

Si vous utilisez Prisma, l'ajout de l'option sslaccept=strict permet de garantir une connexion chiffrée. Exemple de configuration :

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

Utiliser MySQL avec Django

Si le module mysqlclient n'est pas encore installé, vous pouvez l'installer avec :

pip install mysqlclient

Si vous obtenez l'erreur Exception: Can not find valid pkg-config name lors de l'installation, il peut être nécessaire d'ajouter le package libmysqlclient. Sur Ubuntu/Debian, utilisez : apt-get update && apt-get install --no-install-recommends -y libmysqlclient-dev

Pour tester la connexion, vous pouvez d'abord stocker le mot de passe directement dans votre fichier settings.py. Pour la sécurité à long terme, il est préférable d'utiliser des variables d'environnement (voir ci-dessous).

Modifiez votre settings.py comme ceci :

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>'
  }
}

Attention : cet exemple est destiné uniquement aux tests et n'est pas recommandé en production !

Après avoir vérifié que la connexion fonctionne, vous pouvez passer à une approche plus sécurisée avec django-environ pour gérer les variables d'environnement.

Commencez par installer le package :

pip install django-environ

Puis, mettez à jour votre 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')
  }
}

Créez ou modifiez le fichier .env dans le même dossier que settings.py et ajoutez :

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

Enfin, pour sécuriser vos identifiants, ajoutez .env à votre fichier .gitignore :

echo ".env" >> .gitignore

Connecter MySQL avec Java/Spring

Pour connecter votre application Spring, définissez la variable d'environnement SPRING_DATASOURCE_URL avec l'URL de votre base, en la préfixant par jdbc: :

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

Connecter MySQL avec Groovy/Grails

Voici un exemple de configuration de votre application Grails pour se connecter à MySQL :

dataSource {
  pooled = true
  driverClassName = "com.mysql.cj.jdbc.Driver"
  dialect = org.hibernate.dialect.MySQL8Dialect
  // Propriétés spécifiques 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" // Vous pouvez remplacer "/root" par la base de votre choix.
      username = "root" // Il est conseillé de créer un utilisateur dédié pour votre application.
      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"
      }
    }
  }
}

Créer un utilisateur MySQL avec phpMyAdmin

Pour renforcer la sécurité, il est recommandé de créer un utilisateur dédié pour votre application au lieu d'utiliser l'utilisateur "root". Vous pouvez le faire facilement avec phpMyAdmin :

  1. Dans phpMyAdmin, sélectionnez Comptes utilisateurs dans le menu principal.

  2. Cliquez sur Ajouter un compte utilisateur.

  3. Remplissez le formulaire de création :

    • Saisissez un nom de compte (généralement le nom de votre application)
    • Cliquez sur Générer un mot de passe pour obtenir un mot de passe sécurisé et copiez-le
    • Sélectionnez Créer une base portant son nom et donner tous les privilèges

Une fois le formulaire validé, vous disposerez d'un nouvel utilisateur et d'une base dédiée portant le même nom que votre nom d'utilisateur.

Autres articles pour MySQL

  1. Introduction
    Introduction à MySQL
  2. Utilisation avancée
    Comment configurer, optimiser, exporter ou importer des données MySQL
  3. Configurer les GUIs
    Comment connecter des interfaces graphiques à MySQL
  4. Dépannage
    Problèmes courants et solutions pour MySQL
  5. Workbench
    Comment configurer MySQL Workbench