Herstellen einer Verbindung mit Azure Database for MySQL – Flexible Server mit verschlüsselten Verbindungen

In diesem Artikel erfahren Sie, wie Sie:

• Konfigurieren Ihrer Instanz von Azure Database for MySQL – flexibler Server
  • Bei deaktiviertem SSL
  • Bei SSL, das mit der TLS-Version erzwungen wurde
• Herstellen einer Verbindung mit Ihrer Azure Database for MySQL Flexible Server-Instanz mithilfe der Mysql-Befehlszeile
  • Bei deaktivierten verschlüsselten Verbindungen
  • Bei aktivierten verschlüsselten Verbindungen
• Überprüfen des Verschlüsselungsstatus bei Ihrer Verbindung
• Herstellen einer Verbindung mit Ihrer Azure Database for MySQL Flexible Server-Instanz mit verschlüsselten Verbindungen mithilfe verschiedener Anwendungsframeworks

Übersicht über die TLS/SSL-Unterstützung in Der Azure-Datenbank für MySQL Flexible Server

Azure Database for MySQL Flexible Server unterstützt das Verbinden Ihrer Clientanwendungen mit der Azure Database for MySQL Flexible Server-Instanz mithilfe von SSL (Secure Sockets Layer) mit TLS-Verschlüsselung (Transport Layer Security). TLS ist ein Branchenstandardprotokoll, das verschlüsselte Netzwerkverbindungen zwischen Ihrem Datenbankserver und Clientanwendungen sicherstellt, sodass Sie complianceanforderungen einhalten können.

Azure Database for MySQL Flexible Server unterstützt verschlüsselte Verbindungen standardmäßig mithilfe von TLS 1.2 (Transport Layer Security) und verweigert standardmäßig alle eingehenden Verbindungen mithilfe von TLS 1.0 und TLS 1.1. Sie können die Verschlüsselte Verbindungserzwingungs- oder TLS-Versionskonfiguration auf Ihrem flexiblen Server ändern, wie in diesem Artikel beschrieben.

In der folgenden Tabelle werden die verschiedenen Konfigurationen von SSL- und TLS-Einstellungen beschrieben, die Sie für Ihre Azure Database for MySQL Flexible Server-Instanz haben können:

Deaktivieren der TLS-Erzwingung in Ihrer Azure-Datenbank für MySQL Flexible Server-Instanz

Wenn Ihre Clientanwendung keine verschlüsselten Verbindungen unterstützt, müssen Sie die Erzwingung von verschlüsselten Verbindungen auf Ihrer Instanz von Azure Database for MySQL – flexibler Server deaktivieren. Um die Erzwingung verschlüsselter Verbindungen zu deaktivieren, setzen Sie den Serverparameter require_secure_transport wie im folgenden Screenshot gezeigt auf OFF und speichern Sie die Serverparameterkonfiguration, damit die Änderung wirksam wird. require_secure_transport ist ein dynamischer Serverparameter , der sofort wirksam wird und keinen Serverneustart erfordert.

Verbinden mithilfe des Mysql-Befehlszeilenclients mit deaktivierter TLS-Funktion

Das folgende Beispiel zeigt, wie Sie mithilfe der Mysql-Befehlszeilenschnittstelle eine Verbindung mit Ihrem Server herstellen. Verwenden Sie die Einstellung --ssl-mode=DISABLED der Verbindungszeichenfolge, um die TLS/SSL-Verbindung über den mysql-Client zu deaktivieren. Ersetzen Sie die Werte durch den tatsächlichen Servernamen und das Kennwort.

 mysql.exe -h mydemoserver.mysql.database.azure.com -u myadmin -p --ssl-mode=DISABLED

 mysql.exe -h mydemoserver.mysql.database.azure.com -u myadmin -p --ssl-mode=REQUIRED

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 17
Server version: 5.7.29-log MySQL Community Server (GPL)

Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show global variables like '%require_secure_transport%';
+--------------------------+-------+
| Variable_name | Value |
| +--------------------------+-------+ |
| require_secure_transport | OFF |
| +--------------------------+-------+ |
| 1 row in set (0.02 sec) |

Zusammenfassend lockert die Einstellung require_secure_transport=OFF die Erzwingung verschlüsselter Verbindungen. Daher akzeptiert der Server zusätzlich zu verschlüsselten Verbindungen unverschlüsselte Verbindungen.

TLS-Version erzwingen

Wenn Sie TLS-Versionen für Ihre Azure Database for MySQL flexible Serverinstanz festlegen möchten, legen Sie den tls_version Serverparameter fest. Die Standardeinstellung für das TLS-Protokoll ist TLS 1.2. Wenn Ihre Anwendung Verbindungen mit MySQL-Server mit TLS unterstützt, aber ein anderes Protokoll als TLS 1.2 erfordert, legen Sie die TLS-Versionen im Serverparameter fest.

tls_version ist ein statischer Serverparameter , der einen Serverneustart erfordert, damit der Parameter wirksam wird.

Herstellen einer Verbindung mithilfe des Mysql-Befehlszeilenclients mit TLS/SSL

Herunterladen des öffentlichen SSL-Zertifikats

Um verschlüsselte Verbindungen mit Ihren Clientanwendungen herzustellen, laden Sie das DigiCert Global Root G2-Zertifikat und das Microsoft RSA Root Certificate Authority 2017-Zertifikat herunter. Kombinieren Sie beide Zertifikate, bevor Sie eine Verbindung mit dem Server initiieren. Ausführliche Schritte finden Sie unter Aktualisieren des Stammzertifikatspeichers auf Ihrem Client.

Speichern Sie die Zertifikatdatei am gewünschten Ort. In diesem Tutorial wird c:\ssl oder \var\www\html\bin für Ihre lokale Umgebung oder die Clientumgebung verwendet, wo die Anwendung gehostet wird.

Wenn Sie die Instanz von Azure Database for MySQL – flexibler Server mit Privater Zugriff (VNet-Integration) erstellt haben, müssen Sie eine Verbindung mit der Serverinstanz über eine Ressource innerhalb desselben virtuellen Netzwerks herstellen. Sie können einen virtuellen Computer erstellen und zum virtuellen Netzwerk hinzufügen, das mit Ihrer Instanz von Azure Database for MySQL – flexibler Server erstellt wurde.

Wenn Sie Ihre Instanz von Azure Database for MySQL – flexibler Server mit Öffentlicher Zugriff (zulässige IP-Adressen) erstellt haben, können Sie die lokale IP-Adresse der Liste der Firewallregeln für die Serverinstanz hinzufügen.

Sie können entweder mysql.exe oder MySQL Workbench mit Azure Database for MySQL verwenden – Flexibler Server, um über Ihre lokale Umgebung eine Verbindung mit dem Server herzustellen.

Das folgende Beispiel zeigt, wie Sie mithilfe der Mysql-Befehlszeilenschnittstelle eine Verbindung mit Ihrem Server herstellen. Verwenden Sie die Einstellung --ssl-mode=REQUIRED für die Verbindungszeichenfolge, um die Überprüfung des TLS-/SSL-Zertifikats zu erzwingen. Übergeben Sie den Pfad der lokalen Zertifikatdatei an den Parameter --ssl-ca. Ersetzen Sie die Werte durch den tatsächlichen Servernamen und das Kennwort.

sudo apt-get install mysql-client
wget --no-check-certificate https://cacerts.digicert.com/DigiCertGlobalRootG2.crt.pem
mysql -h mydemoserver.mysql.database.azure.com -u mydemouser -p --ssl-mode=REQUIRED --ssl-ca=DigiCertGlobalRootG2.crt.pem

Wenn Sie versuchen, eine Verbindung mit Ihrem Server mit unverschlüsselten Verbindungen herzustellen, wird ein Fehler angezeigt, der besagt, dass Verbindungen mit unsicheren Transporten verboten sind:

ERROR 3159 (HY000): Connections using insecure transport are prohibited while --require_secure_transport=ON.

Überprüfen der TLS-Verbindung

Führen Sie den MySQL-Befehl status aus, um zu überprüfen, ob Sie mit TLS verbunden sind:

mysql> status

Vergewissern Sie sich, dass die Verbindung verschlüsselt ist, indem Sie die Ausgabe überprüfen, die Folgendes anzeigen sollte: SSL: Verwendete Verschlüsselung ist. Diese Verschlüsselungssuite zeigt ein Beispiel, und basierend auf dem Client können Sie eine andere Verschlüsselungssuite sehen.

Wie kann ich die TLS-Protokolle identifizieren, die auf meinem Server konfiguriert sind?

Führen Sie den Befehl SHOW GLOBAL VARIABLES LIKE 'tls_version'; aus, und überprüfen Sie den Wert, um zu verstehen, welche Protokolle konfiguriert sind.

mysql> SHOW GLOBAL VARIABLES LIKE 'tls_version';

Wie finde ich, welche TLS-Protokolle meine Clients zum Herstellen einer Verbindung mit dem Server verwenden?

Führen Sie die SQL-Abfrage aus, um die in dieser Verbindung verwendete TLS-Version zu überprüfen:

SELECT sbt.variable_value AS tls_version,  t2.variable_value AS cipher,
processlist_user AS user, processlist_host AS host
FROM performance_schema.status_by_thread  AS sbt
JOIN performance_schema.threads AS t ON t.thread_id = sbt.thread_id
JOIN performance_schema.status_by_thread AS t2 ON t2.thread_id = t.thread_id
WHERE sbt.variable_name = 'Ssl_version' and t2.variable_name = 'Ssl_cipher' ORDER BY tls_version;

Herstellen einer Verbindung mit Ihrer Azure Database for MySQL Flexible Server-Instanz mit verschlüsselten Verbindungen mithilfe verschiedener Anwendungsframeworks

Verbindungszeichenfolgen, die auf der Seite "Verbindungszeichenfolgen" vordefiniert sind, die für Ihren Server im Azure Portal verfügbar sind, enthalten die erforderlichen Parameter für gemeinsame Sprachen, um mithilfe von TLS/SSL eine Verbindung mit Ihrem Datenbankserver herzustellen. Der TLS/SSL-Parameter variiert je nach Connector. Verwenden Sie zum Beispiel useSSL=true, sslmode=required oder ssl_verify_cert=true sowie andere Varianten.

Sie können die folgenden Codebeispiele nutzen, um in Ihrer Anwendung über TLS/SSL eine verschlüsselte Verbindung mit Ihrer Instanz von Azure Database for MySQL – flexibler Server einzurichten:

WordPress

Laden Sie das öffentliche SSL-Zertifikat herunter, und fügen Sie die folgenden Zeilen nach wp-config.php der Zeile // **MySQL settings - You can get this info from your web host** //hinzu.

//** Connect with SSL ** //
define('MYSQL_CLIENT_FLAGS', MYSQLI_CLIENT_SSL);
//** SSL CERT **//
define('MYSQL_SSL_CERT','/FULLPATH/on-client/to/DigiCertGlobalRootG2.crt.pem');

PHP

$conn = mysqli_init();
mysqli_ssl_set($conn,NULL,NULL, "/var/www/html/DigiCertGlobalRootG2.crt.pem", NULL, NULL);
mysqli_real_connect($conn, 'mydemoserver.mysql.database.azure.com', 'myadmin', 'yourpassword', 'quickstartdb', 3306, MYSQLI_CLIENT_SSL);
if (mysqli_connect_errno()) {
die('Failed to connect to MySQL: '.mysqli_connect_error());
}

PHP (mit PDO)

$options = array(
    PDO::MYSQL_ATTR_SSL_CA => '/var/www/html/DigiCertGlobalRootG2.crt.pem'
);
$db = new PDO('mysql:host=mydemoserver.mysql.database.azure.com;port=3306;dbname=databasename', 'myadmin', 'yourpassword', $options);

Python (MySQLConnector Python)

try:
    conn = mysql.connector.connect(user='myadmin',
                                   password='<password>',
                                   database='quickstartdb',
                                   host='mydemoserver.mysql.database.azure.com',
                                   ssl_ca='/var/www/html/DigiCertGlobalRootG2.crt.pem')
except mysql.connector.Error as err:
    print(err)

Python (PyMySQL)

conn = pymysql.connect(user='myadmin',
                       password='<password>',
                       database='quickstartdb',
                       host='mydemoserver.mysql.database.azure.com',
                       ssl={'ca': '/var/www/html/DigiCertGlobalRootG2.crt.pem'})

Django (PyMySQL)

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'quickstartdb',
        'USER': 'myadmin',
        'PASSWORD': 'yourpassword',
        'HOST': 'mydemoserver.mysql.database.azure.com',
        'PORT': '3306',
        'OPTIONS': {
            'ssl': {'ca': '/var/www/html/DigiCertGlobalRootG2.crt.pem'}
        }
    }
}

Ruby

client = Mysql2::Client.new(
        :host     => 'mydemoserver.mysql.database.azure.com',
        :username => 'myadmin',
        :password => 'yourpassword',
        :database => 'quickstartdb',
        :sslca => '/var/www/html/DigiCertGlobalRootG2.crt.pem'
    )

Golang

rootCertPool := x509.NewCertPool()
pem, _ := ioutil.ReadFile("/var/www/html/DigiCertGlobalRootG2.crt.pem")
if ok := rootCertPool.AppendCertsFromPEM(pem); !ok {
    log.Fatal("Failed to append PEM.")
}
mysql.RegisterTLSConfig("custom", &tls.Config{RootCAs: rootCertPool})
var connectionString string
connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true&tls=custom",'myadmin' , 'yourpassword', 'mydemoserver.mysql.database.azure.com', 'quickstartdb')
db, _ := sql.Open("mysql", connectionString)

Java (MySQL-Connector für Java)

# generate truststore and keystore in code

String importCert = " -import "+
    " -alias mysqlServerCACert "+
    " -file " + ssl_ca +
    " -keystore truststore "+
    " -trustcacerts " +
    " -storepass password -noprompt ";
String genKey = " -genkey -keyalg rsa " +
    " -alias mysqlClientCertificate -keystore keystore " +
    " -storepass password123 -keypass password " +
    " -dname CN=MS ";
sun.security.tools.keytool.Main.main(importCert.trim().split("\\s+"));
sun.security.tools.keytool.Main.main(genKey.trim().split("\\s+"));

# use the generated keystore and truststore

System.setProperty("javax.net.ssl.keyStore","path_to_keystore_file");
System.setProperty("javax.net.ssl.keyStorePassword","password");
System.setProperty("javax.net.ssl.trustStore","path_to_truststore_file");
System.setProperty("javax.net.ssl.trustStorePassword","password");

url = String.format("jdbc:mysql://%s/%s?serverTimezone=UTC&useSSL=true", 'mydemoserver.mysql.database.azure.com', 'quickstartdb');
properties.setProperty("user", 'myadmin');
properties.setProperty("password", 'yourpassword');
conn = DriverManager.getConnection(url, properties);

Java (MariaDB-Connector für Java)

# generate truststore and keystore in code

String importCert = " -import "+
    " -alias mysqlServerCACert "+
    " -file " + ssl_ca +
    " -keystore truststore "+
    " -trustcacerts " +
    " -storepass password -noprompt ";
String genKey = " -genkey -keyalg rsa " +
    " -alias mysqlClientCertificate -keystore keystore " +
    " -storepass password123 -keypass password " +
    " -dname CN=MS ";
sun.security.tools.keytool.Main.main(importCert.trim().split("\\s+"));
sun.security.tools.keytool.Main.main(genKey.trim().split("\\s+"));

# use the generated keystore and truststore

System.setProperty("javax.net.ssl.keyStore","path_to_keystore_file");
System.setProperty("javax.net.ssl.keyStorePassword","password");
System.setProperty("javax.net.ssl.trustStore","path_to_truststore_file");
System.setProperty("javax.net.ssl.trustStorePassword","password");

url = String.format("jdbc:mariadb://%s/%s?useSSL=true&trustServerCertificate=true", 'mydemoserver.mysql.database.azure.com', 'quickstartdb');
properties.setProperty("user", 'myadmin');
properties.setProperty("password", 'yourpassword');
conn = DriverManager.getConnection(url, properties);

.NET (MySqlConnector)

var builder = new MySqlConnectionStringBuilder
{
    Server = "mydemoserver.mysql.database.azure.com",
    UserID = "myadmin",
    Password = "yourpassword",
    Database = "quickstartdb",
    SslMode = MySqlSslMode.VerifyCA,
    SslCa = "DigiCertGlobalRootG2.crt.pem",
};
using (var connection = new MySqlConnection(builder.ConnectionString))
{
    connection.Open();
}

Node.js

var fs = require('fs');
var mysql = require('mysql');
const serverCa = [fs.readFileSync("/var/www/html/DigiCertGlobalRootG2.crt.pem", "utf8")];
var conn=mysql.createConnection({
    host:"mydemoserver.mysql.database.azure.com",
    user:"myadmin",
    password:"yourpassword",
    database:"quickstartdb",
    port:3306,
    ssl: {
        rejectUnauthorized: true,
        ca: serverCa
    }
});
conn.connect(function(err) {
  if (err) throw err;
});

Verwandte Inhalte

• Verwenden von MySQL-Workbench mit Azure Database for MySQL – Flexibler Server
• Verwenden Sie PHP mit der Azure-Datenbank für MySQL - Flexible Server
• Erstellen und Verwalten virtueller Netzwerke für Azure Database for MySQL Flexible Server über die Azure CLI
• Netztechnologie in Azure Database for MySQL – flexibler Server
• Firewallregeln für Azure Database for MySQL-Server – flexibler Server