Installation et configuration de MySQL sur Ubuntu 20.04

Les utilisateurs d'Ubuntu ont le choix entre deux systèmes de gestion de bases de données relationnelles fiables (SGBD),MySQL etMariaDB . MySQL jouit d'une popularité de longue date, mais MariaDB suscite un intérêt accru en raison de ses avantages en termes de performances et de ses fonctionnalités supplémentaires. Ce guide compare les deux systèmes de base de données et fournit des instructions sur l'installation et l'utilisation de MySQL sur Ubuntu 20.04.

Qu'est-ce que MySQL ?

Le SGBDR MySQL est l'une des applications open source les plus populaires. Il fait partie de la pile LAMP , qui est la pierre angulaire de nombreux systèmes Ubuntu. Cette pile se compose de Linux, du serveur Web Apache, du SGBDR MySQL et du langage de programmation PHP. Ces applications fonctionnent ensemble pour prendre en charge les applications Web, le développement de logiciels et les activités spécialisées telles que la science des données. MySQL est principalement utilisé dans les configurations à serveur unique de petite à moyenne taille.

Les requêtes MySQL sont écrites dans le Structured Query Language (SQL). En tant que base de données relationnelle, elle stocke et organise les données dans des tables. Les tables structurent les données réelles à l'intérieur des tables sous la forme d'une série de lignes, chaque ligne étant constituée d'une ou de plusieurs colonnes. Chaque ligne représente une entrée différente dans le tableau, tandis que chaque colonne contient un champ de données dans l'entrée. Les champs de données de ces tables peuvent être liés les uns aux autres, et ces relations aident à structurer et à organiser la base de données. Des instructions SQL spécialisées permettent aux clients d'ajouter, de supprimer, de modifier et de récupérer des données.

MySQL est connu pour sa stabilité et sa fiabilité et est considéré comme simple et facile à utiliser. Il est disponible en tant que logiciel open source gratuit sous la licence publique générale GNU. MySQL est facilement disponible pour toutes les distributions Linux ainsi que pour d'autres systèmes d'exploitation. Il appartient maintenant à Oracle Corporation. Oracle propose également l'édition commerciale de MySQL Enterprise en tant que produit haut de gamme.

MySQL contre MariaDB

Les deux principales alternatives de base de données open source, MySQL et MariaDB, sont très similaires. Ce sont tous deux des produits RDBMS et tous deux utilisent SQL. Les deux systèmes de base de données ont des versions gratuites, et ils se ressemblent et agissent à peu près de la même manière. Étant donné que MariaDB est à l'origine une branche de MySQL, ce n'est pas surprenant. MariaDB a depuis subi d'autres développements et présente de nombreuses nouvelles améliorations en matière de sécurité et de performances. Avec MySQL, cependant, de nombreuses fonctionnalités avancées ne se trouvent que dans l'édition Enterprise. Voici un résumé des similitudes et des différences entre les deux produits :

MariaDB prend en charge plus de connexions que MySQL.
Les deux bases de données peuvent fonctionner avec plusieurs systèmes de stockage, bien que MariaDB offre plus d'options.
MariaDB peut répliquer les données plus rapidement que MySQL et offre de meilleures performances globales. MySQL gère plus efficacement les transactions volumineuses, mais MariaDB fonctionne mieux dans des situations à grande échelle.
MySQL prend en charge certaines fonctionnalités que MariaDB n'a pas, telles que les colonnes dynamiques. Chaque base de données possède quelques fonctionnalités et améliorations avancées que l'autre n'a pas.
MySQL est plus ancien, mieux établi, plus populaire et bénéficie d'un meilleur support communautaire. MySQL propose des plans d'assistance payants plus complets.
MariaDB et MySQL sont entièrement compatibles.
Les deux produits sont open source, mais le modèle de licence MySQL est plus restrictif.

Pour résumer, les deux systèmes sont plus que suffisants pour la plupart des utilisateurs. MariaDB offre de meilleures performances, tandis que MySQL est mieux établi et mieux pris en charge.

Avant de commencer

Si vous ne l'avez pas déjà fait, créez un compte Linode et une instance de calcul. Consultez nos guides Premiers pas avec Linode et Création d'une instance de calcul.
Suivez notre guide Configuration et sécurisation d'une instance de calcul pour mettre à jour votre système. Vous pouvez également définir le fuseau horaire, configurer votre nom d'hôte, créer un compte utilisateur limité et renforcer l'accès SSH.

Remarque Les étapes de ce guide sont écrites pour les utilisateurs non root. Les commandes qui nécessitent des privilèges élevés sont préfixées par sudo . Si vous n'êtes pas familier avec le sudo commande, consultez le guide Linux Users and Groups.

Comment installer le serveur MySQL

MySQL est disponible dans le cadre des packages Ubuntu par défaut, il n'est donc pas nécessaire de modifier la liste des sources. Il peut être facilement installé en utilisant apt , mais il est important de sécuriser l'application et de modifier le pare-feu par la suite. Ces instructions sont destinées aux utilisateurs d'Ubuntu, mais sont généralement applicables à ceux qui souhaitent installer MySQL sur une autre distribution Linux.

Télécharger MySQL

Pour installer le serveur MySQL sur Ubuntu, suivez les étapes ci-dessous :

Installez l'application serveur MySQL.
```
sudo apt install mysql-server
```

Confirmez que le serveur MySQL est en cours d'exécution à l'aide de systemctl commande. Il devrait afficher un statut active .

sudo systemctl status mysql

mysql.service - MySQL Community Server
    Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset:>
    Active: active (running) since Thu 2021-09-09 12:24:29 UTC; 1h 44min ago

Configurer le serveur MySQL sous Linux

Le mysql_secure_installation est le moyen le plus simple de configurer l'application. Pour utiliser le script de configuration, procédez comme suit :

Lancez mysql_secure_installation utilitaire pour définir le mot de passe root et configurer d'autres options par défaut.
```
sudo mysql_secure_installation
```

L'application demande s'il faut activer le VALIDATE PASSWORD COMPONENT composant. Si vous répondez y , il demande ensuite s'il faut définir la force du mot de passe sur LOW , MEDIUM , ou HIGH .

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

À l'invite suivante, l'utilitaire demande un mot de passe pour le compte root. Définissez le mot de passe, puis ressaisissez-le.
```
Please set the password for root here.

New password:

Re-enter new password:
```

Les questions suivantes demandent s'il faut supprimer les utilisateurs anonymes, pour autoriser le root compte pour se connecter à distance, et supprimer le test base de données. Entrez y ou n à chaque invite selon vos préférences. Le test la base de données est utile lors de la validation initiale, mais pour des raisons de sécurité, il est préférable d'interdire la root compte de se connecter à distance.

By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.

Remove anonymous users? (Press y|Y for Yes, any other key for No) :

Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.

Disallow root login remotely? (Press y|Y for Yes, any other key for No) :

By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.

Remove test database and access to it? (Press y|Y for Yes, any other key for No

Lorsque vous y êtes invité, rechargez le privilege tables pour mettre à jour la base de données.

Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.

Reload privilege tables now? (Press y|Y for Yes, any other key for No)

Success.

All done!

(Facultatif ) Pour accéder à MySQL à distance, assurez-vous que le trafic MySQL est autorisé via ufw pare-feu. Ajoutez la règle suivante pour ouvrir le port 3306 sur le pare-feu. Cette règle ne doit pas être ajoutée si l'accès à distance n'est pas requis.

ufw allow mysql

Status: active

To                         Action      From
--                         ------      ----
Apache Full                ALLOW       Anywhere
OpenSSH                    ALLOW       Anywhere
3306/tcp                   ALLOW       Anywhere
Apache Full (v6)           ALLOW       Anywhere (v6)
OpenSSH (v6)               ALLOW       Anywhere (v6)
3306/tcp (v6)              ALLOW       Anywhere (v6)

Se connecter à MySQL en tant qu'utilisateur racine

Bien que la root l'utilisateur a un accès complet à la base de données MySQL, son utilisation doit être réservée à des fins administratives. Cela réduit le risque d'écraser accidentellement des sections critiques de la base de données. Même dans une configuration mono-utilisateur, un compte utilisateur distinct doit être créé pour la plupart des activités MySQL.

Pour accéder au serveur MySQL en tant que root utilisateur et créez un nouveau compte utilisateur, suivez ces étapes :

Utilisez le sudo mysql commande pour accéder à la base de données. MySQL authentifie l'utilisateur racine en fonction de ses informations d'identification racine lors de la connexion locale, donc aucun mot de passe n'est requis. Vous pouvez également accéder au compte root en utilisant sudo mysql -u root -p , ainsi que la root mot de passe.
```
sudo mysql
```

MySQL affiche le numéro de version et quelques informations sur l'installation, puis présente l'invite MySQL.

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 15
Server version: 8.0.26-0ubuntu0.20.04.2 (Ubuntu)
...
mysql>

Pour confirmer que MySQL fonctionne correctement, utilisez le SHOW DATABASES commande pour afficher toutes les bases de données.

SHOW DATABASES;

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.01 sec)

Créez un nouvel utilisateur en utilisant le CREATE USER commande. Entrez le nom d'utilisateur au format 'username'@'IP_Address' , où IP_Address est l'adresse IP de l'utilisateur. Si l'utilisateur accède à MySQL à partir du Linode local, remplacez localhost à la place de l'adresse IP. Dans la commande ci-dessous, remplacez mysqluser et password avec le nom d'utilisateur et le mot de passe réels.

Remarque MySQL propose plusieurs mécanismes d'authentification différents. Le caching_sha2_password est recommandée pour les utilisateurs qui souhaitent se connecter à l'aide d'un mot de passe et est utilisée ici. Cependant, certaines applications plus anciennes peuvent ne pas être en mesure de s'authentifier correctement de cette façon. Dans ce cas, mysql_native_password devrait être utilisé à la place. La réplication MySQL source-réplica peut nécessiter le sha256_password méthode.
```
CREATE USER 'mysqluser'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';
```
Accordez l'accès au nouvel utilisateur à l'aide du GRANT PRIVILEGE commande, en utilisant le format GRANT list of privileges ON table TO 'username'@'IP_Address'; . Certains des privilèges les plus courants incluent CREATE , ALTER , DROP , INSERT , UPDATE , DELETE , et SELECT . Pour appliquer ces privilèges à toutes les bases de données, utilisez la variable générique *.* . La commande suivante accorde des privilèges non administratifs communs sur toutes les bases de données à mysqluser .
```
GRANT CREATE, ALTER, DROP, INSERT, UPDATE, DELETE, SELECT, REFERENCES, RELOAD ON *.* TO 'mysqluser'@'localhost' WITH GRANT OPTION;
```
Pour quitter l'invite MySQL, tapez exit .
```
exit
```

Comment utiliser MySQL

MySQL utilise la syntaxe SQL standard pour toutes ses commandes. Les étapes de cette section montrent comment effectuer des tâches de base dans MySQL, telles que la création de bases de données, de tables et l'ajout de données. Pour plus d'informations sur l'utilisation de MySQL, consultez le manuel de référence MySQL. Pour une introduction brève mais approfondie, essayez le tutoriel MySQL.

Créer une base de données

Pour créer une base de données, connectez-vous à MySQL en utilisant un compte contenant CREATE privilèges. Remplacez mysqlusername avec le nom d'utilisateur que vous avez créé.
```
mysql -u mysqlusername -p
```
Créez une nouvelle base de données en utilisant le CREATE DATABASE commande. Remplacez newdatabasename avec le nom souhaité pour votre base de données.
```
CREATE DATABASE newdatabasename;
```
```
Query OK, 1 row affected (0.00 sec)
```

Pour confirmer que la nouvelle base de données a été créée correctement, utilisez SHOW DATABASES .

SHOW DATABASES;

+--------------------+
| Database           |
+--------------------+
...
| newdatabasename   |
...
+--------------------+
5 rows in set (0.00 sec)

Indiquez la base de données avec laquelle vous souhaitez travailler à l'aide de USE commande. Remplacez newdatabasename avec le nom de la base de données que vous venez de créer.
```
USE newdatabasename;
```
```
Database changed
```
Remarque Vous pouvez également utiliser le USE lorsque vous avez plusieurs bases de données et que vous souhaitez basculer entre elles.
Pour connaître le nom de la base de données en cours, utilisez le SELECT DATABASE commande. La sortie affiche le nom de la base de données.
```
SELECT DATABASE();
```
```
+------------------+
| DATABASE()       |
+------------------+
| newdatabasename |
+------------------+
```

Créer un tableau

À ce stade, la base de données, newdatabasename n'a pas de tables, il n'est donc pas encore possible d'y stocker des données. Pour définir une table, utilisez le CREATE TABLE commande. Outre le nom de la table, cette commande nécessite le nom et le type de données de chaque champ. Le type de données caractérise les données stockées dans le champ. Par exemple, le type de données peut être une chaîne de longueur variable, appelée VARCHAR . Pour une liste complète des types de données, consultez la documentation MySQL. Certains des types de données les plus courants sont les suivants.

INT : Cela peut contenir une valeur entre -2147483648 et 2147483647 . Si spécifié comme UNSIGNED , il peut stocker des valeurs entre 0 et 4294967295 .
PETITE : Contient une valeur entière encore plus petite entre -32768 et 32767 .
FLOAT : Ce type peut stocker un nombre à virgule flottante.
DATE : Stocke une date en YYYY-MM-DD formater.
DATEHEURE : Stocke une combinaison de date et d'heure dans YYYY-MM-DD HH:MM:SS format. La même heure peut être stockée sans tirets ni deux-points dans le TIMESTAMP formater.
VARCHAR(N) : Ceci est une chaîne de longueur variable entre 1 et N caractères, avec une longueur maximale de 255 caractères.
TEXTE : Ce type de données peut contenir jusqu'à 65535 personnages. Il peut contenir du texte, des images ou des données binaires.
CAR(N) : Ce type représente un champ de texte de longueur fixe de longueur N . Par exemple, pour contenir des codes d'état à deux caractères, utilisez un type de données CHAR(2) .

Avant de créer des tables, il est important de choisir un schéma pour la base de données. Le schéma décrit ce que chaque table représente, quelles données sont stockées dans chaque table et comment les tables sont liées. Pour créer un tableau, procédez comme suit :

Une fois connecté à MySQL, passez à la base de données dans laquelle vous souhaitez ajouter la table.
```
use newdatabasename;
```
Utilisez le CREATE TABLE commande pour générer une nouvelle table. Utilisez le format CREATE TABLE table_name (field_1 datatype, field_n datatype); .
```
CREATE TABLE newtablename (column1 VARCHAR(20), column2 CHAR(1), column3 DATE, column4 SMALLINT UNSIGNED);
```
```
Query OK, 0 rows affected (0.02 sec)
```

Pour confirmer que la table existe maintenant, utilisez le SHOW TABLES commande.

SHOW TABLES;

+----------------------------+
| Tables_in_newdatabasename |
+----------------------------+
| newtablename              |
+----------------------------+
1 row in set (0.00 sec)

Pour revoir la structure de la table et vérifier la liste des champs, utilisez le DESCRIBE commande.

DESCRIBE newtablename;

+---------+-------------------+------+-----+---------+-------+
| Field   | Type              | Null | Key | Default | Extra |
+---------+-------------------+------+-----+---------+-------+
| column1 | varchar(20)       | YES  |     | NULL    |       |
| column2 | char(1)           | YES  |     | NULL    |       |
| column3 | date              | YES  |     | NULL    |       |
| column4 | smallint unsigned | YES  |     | NULL    |       |
+---------+-------------------+------+-----+---------+-------+
4 rows in set (0.00 sec)

Si une table n'est plus nécessaire, supprimez-la à l'aide de la commande DROP TABLE commande.

Attention Lorsqu'une table est supprimée, toutes les données qu'elle contient sont perdues et ne peuvent pas être récupérées.
```
DROP TABLE newtablename;
```

Ajouter et récupérer des données

La principale façon d'insérer une nouvelle ligne de données dans une table est avec le INSERT commande.

Pour ajouter une ligne, utilisez le INSERT commande. Spécifiez le nom de la table, le mot-clé VALUES , et une liste de valeurs entre crochets et séparées par des virgules au format INSERT INTO tablename VALUES ('value_1', ... 'value_n'); . Les valeurs de colonne doivent avoir la même séquence que la définition de table, avec les valeurs de chaîne et de date entre guillemets. Par exemple, pour ajouter des données à newtablename , spécifiez des valeurs pour column1 , column2 , column3 , et column4 , dans cet ordre.
```
INSERT INTO newtablename VALUES ('value1','a','2021-09-10',123);
```
```
Query OK, 1 row affected (0.01 sec)
```
Pour récupérer des données, utilisez le SELECT commande, ainsi que certaines contraintes indiquant à MySQL quelles lignes renvoyer. Le contenu entier de la table peut être retourné, ou seulement un sous-ensemble. Pour sélectionner toutes les lignes d'un tableau, utilisez le SELECT * commande, mais n'ajoutez aucun qualificatif.
```
SELECT * FROM newtablename;
```
```
+---------+---------+------------+---------+
| column1 | column2 | column3    | column4 |
+---------+---------+------------+---------+
| value1  | a       | 2021-09-10 |     123 |
| value2  | b       | 2021-09-08 |     123 |
+---------+---------+------------+---------+
2 rows in set (0.00 sec)
```
Il est également possible de sélectionner uniquement les lignes répondant à des critères particuliers, par exemple, lorsqu'une colonne est définie sur une certaine valeur. Utilisez le WHERE mot-clé comme qualificatif, suivi des critères de correspondance comme contrainte. Dans cet exemple, seules les lignes dans lesquelles column2 est défini sur b sont affichés.
```
SELECT * FROM newtablename WHERE column2 = 'b';
```
```
+---------+---------+------------+---------+
| column1 | column2 | column3    | column4 |
+---------+---------+------------+---------+
| value2  | b       | 2021-09-08 |     123 |
+---------+---------+------------+---------+
1 row in set (0.00 sec)
```
Pour les tableaux comportant de nombreuses colonnes, il est souvent plus facile de limiter les informations affichées. Pour ne sélectionner que certaines colonnes pour chaque ligne, spécifiez les noms de colonne au lieu de * symbole.
```
SELECT column1, column4 FROM newtablename;
```
```
+---------+---------+
| column1 | column4 |
+---------+---------+
| value1  |     123 |
| value2  |     123 |
+---------+---------+
2 rows in set (0.00 sec)
```
Pour modifier une ligne dans un tableau, utilisez le UPDATE commande. Le SET mot clé indique la colonne à mettre à jour et la nouvelle valeur. Si nécessaire, le WHERE Le mot-clé fournit une méthode pour contraindre l'opération à s'appliquer uniquement à certaines lignes. Dans l'exemple suivant, la valeur de column4 est seulement changé en 155 si column2 est égal à b .
```
UPDATE newtablename SET column4 = 155 WHERE column2 = 'b';
```
```
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
```

Le SELECT * déclaration peut être utilisée pour confirmer la mise à jour.

SELECT * FROM newtablename;

+---------+---------+------------+---------+
| column1 | column2 | column3    | column4 |
+---------+---------+------------+---------+
| value1  | a       | 2021-09-10 |     123 |
| value2  | b       | 2021-09-08 |     155 |
+---------+---------+------------+---------+
2 rows in set (0.00 sec)

Conclusion :MySQL sur Ubuntu 20.04

MySQL est un bon choix pour les petites et moyennes applications Web. Il utilise le langage de programmation SQL standard de l'industrie, qui est assez simple à utiliser. MySQL est très stable et robuste et dispose de nombreuses ressources ainsi que d'un bon support. La principale alternative à MySQL est MariaDB. Il offre de meilleures performances et de nouvelles fonctionnalités, mais n'est pas aussi bien établi.

Vous pouvez facilement télécharger et installer le serveur MySQL sur Ubuntu en utilisant le apt packages et le mysql_secure_installation utilitaire. Même si vous êtes la seule personne à utiliser MySQL, il est préférable de créer un nouvel utilisateur MySQL avec des privilèges plus limités.

Pour utiliser MySQL, déterminez d'abord le schéma de la base de données et définissez le contenu de la table. Ensuite, créez une base de données et les tables de données. Les données peuvent être ajoutées en utilisant le INSERT commande, modifiée à l'aide de la commande UPDATE commande, et récupéré en utilisant le SELECT commande. Bien sûr, MySQL peut effectuer des opérations même très complexes. Parcourez le didacticiel MySQL pour commencer et consultez la documentation MySQL pour un aperçu complet.

Plus d'informations

Vous pouvez consulter les ressources suivantes pour plus d'informations sur ce sujet. Bien que ceux-ci soient fournis dans l'espoir qu'ils seront utiles, veuillez noter que nous ne pouvons pas garantir l'exactitude ou l'actualité des documents hébergés en externe.

Site Web MariaDB
Site Web MySQL