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

GILT FÜR: Azure Database for MySQL – Flexible Server

Azure Database for MySQL Flexibler Server unterstützt das Herstellen einer Verbindung zwischen Ihren Clientanwendungen und Azure Database for MySQL Flexibler Server über Secure Sockets Layer (SSL) mit TLS-(Transport Layer Security-)Verschlüsselung. TLS ist ein Standardprotokoll der Branche, das verschlüsselte Netzwerkverbindungen zwischen dem Datenbankserver und Clientanwendungen gewährleistet, sodass Sie Konformitätsanforderungen einhalten können.

Azure Database for MySQL – Flexible Server unterstützt standardmäßig verschlüsselte Verbindungen mit TLS 1.2, und alle eingehenden Verbindungen mit TLS 1.0 und TLS 1.1 werden standardmäßig verweigert. Die Erzwingung einer verschlüsselten Verbindung oder die TLS-Versionskonfiguration bei Ihrem flexiblen Server kann – wie in diesem Artikel erläutert – geändert werden.

Im Folgenden sind die verschiedenen Konfigurationen von SSL- und TLS-Einstellungen aufgeführt, die Sie bei Ihrer Azure Database for MySQL flexiblen Serverinstanz verwenden können:

Szenario	Einstellungen für Serverparameter	BESCHREIBUNG
Deaktivieren der SSL-Erzwingung	require_secure_transport = OFF	Wenn Ihre Legacy-Anwendung keine verschlüsselten Verbindungen mit Azure Database MySQL Flexibler Server unterstützt, können Sie die Erzwingung von verschlüsselten Verbindungen mit Ihrer Azure Database for MySQL flexiblen Serverinstanz deaktivieren, indem Sie „require_secure_transport=OFF“ festlegen.
Erzwingen von SSL bei der TLS-Version < 1.2	require_secure_transport = ON und tls_version = TLS 1.0 oder TLS 1.1	Wenn Ihre Legacy-Anwendung verschlüsselte Verbindungen unterstützt, aber TLS-Version < 1.2 erfordert, können Sie verschlüsselte Verbindungen aktivieren, müssen aber Ihre Azure DB for MySQL flexible Serverinstanz so konfigurieren, dass Verbindungen mit der von Ihrer Anwendung unterstützten TLS-Version (1.0 oder 1.1) zulässig sind. Nur mit Azure Database for MySQL unterstützt – Flexibler Server, Version v5.7
SSL mit TLS-Version = 1.2 erzwingen (Standardkonfiguration)	require_secure_transport = ON und tls_version = TLS 1.2	Dies ist die empfohlene Standardkonfiguration für Azure Database for MySQL – Flexibler Server.
Erzwingen von SSL mit TLS-Version = 1.3	require_secure_transport = ON und tls_version = TLS 1.3	Dies ist nützlich und wird für die Entwicklung neuer Anwendungen empfohlen. Nur mit Azure Database for MySQL unterstützt – Flexibler Server, Version v8.0

Hinweis

• Änderungen am SSL-Verschlüsselungsverfahren bei einem Azure Database for MySQL flexiblen Server werden nicht unterstützt. FIPS-Verschlüsselungssammlungen werden standardmäßig erzwungen, wenn „tls_version“ auf „TLS-Version 1.2“ festgelegt wird. Bei anderen TLS-Versionen als Version 1.2 wird das SSL-Verschlüsselungsverfahren auf die Standardeinstellungen festgelegt, die in der MySQL-Communityinstallation enthalten sind.
• In den Open-Source-Community-Editionen von MySQL sind die Protokolle TLS 1.0 und TLS 1.1 seit der Veröffentlichung der Versionen 8.0.26 und 5.7.35 veraltet. Diese 1996 bzw. 2006 veröffentlichten Protokolle zur Verschlüsselung von Daten während der Übertragung gelten als schwach, veraltet und anfällig für Sicherheitsbedrohungen. Weitere Informationen finden Sie unter Entfernen der Unterstützung für die Protokolle TLS 1.0 und TLS 1.1. Azure Database for MySQL Flexible Server stellt ebenfalls die Unterstützung von TLS-Versionen ein, sobald die Community die Unterstützung für das Protokoll einstellt, um sich an moderne Sicherheitsstandards anzupassen.

In diesem Artikel werden folgende Vorgehensweisen behandelt:

• 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 Instanz von „Azure Database for MySQL – flexibler Server“ mit 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 Instanz von Azure DB for MySQL – Flexibler Server mit verschlüsselten Verbindungen mithilfe von verschiedenen Anwendungsframeworks

Deaktivieren der SSL-Erzwingung für Ihre Instanz von Azure Database for MySQL – Flexibler Server.

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. Zum Deaktivieren der Erzwingung von verschlüsselten Verbindungen müssen Sie den Serverparameter „require_secure_transport“ auf „OFF“ festlegen, wie im Screenshot gezeigt wird, und die Konfiguration dafür speichern, damit sie wirksam wird. „require_secure_transport“ ist ein dynamischer Serverparameter, der sofort wirksam wird und dafür keinen Serverneustart erfordert.

Herstellen einer Verbindung mithilfe des mysql-Befehlszeilenclients bei deaktiviertem SSL

Das folgende Beispiel zeigt, wie Sie einen Server mithilfe der mysql-Befehlszeilenschnittstelle verbinden können. 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

Wichtig

Wenn „require_secure_transport“ auf „OFF“ festgelegt wird, bedeutet dies nicht, dass verschlüsselte Verbindungen serverseitig nicht unterstützt werden. Wenn Sie „require_secure_transport“ bei einer Instanz von Azure Database for MySQL – Flexibler Server auf „OFF“ festlegen, der Client aber eine Verbindung mit verschlüsselter Verbindung herstellt, wird dies weiterhin akzeptiert. Die folgende Verbindung mithilfe des mysql-Clients bei einer Instanz von Azure Database for MySQL – Flexibler Server, der mit „require_secure_transport=OFF“ konfiguriert wurde, funktioniert wie unten gezeigt ebenfalls.

 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)

Kurz gesagt: „require_secure_transport=OFF“ lockert die Erzwingung verschlüsselter Verbindungen bei Azure Database for MySQL – Flexibler Server und lässt – zusätzlich zu den verschlüsselten Verbindungen – unverschlüsselte Verbindungen mit dem Server über den Client zu.

Erzwingen von SSL mit der TLS-Version

Um TLS-Versionen auf Ihrer Instanz von Azure Database for MySQL – Flexibler Server festzulegen, müssen Sie den Serverparameter „*tls_version-“ festlegen. Die Standardeinstellung für das TLS-Protokoll ist TLS 1.2. Wenn Ihre Anwendung Verbindungen mit dem MySQL-Server mit SSL unterstützt, aber ein anderes Protokoll als TLS 1.2 erfordert, müssen Sie die TLS-Versionen unter Serverparameter festlegen. „tls_version“ ist ein statischer Serverparameter, der einen Serverneustart erfordert, damit er wirksam wird. Im Folgenden finden Sie die unterstützten Protokolle für die verfügbaren Versionen von Azure Database for MySQL – Flexibler Server.

Version von Azure Database for MySQL – Flexible Server	Unterstützte Werte von tls_version	Standardeinstellung
MySQL 5.7	TLS 1.0, TLS 1.1, TLS 1.2	TLS 1.2
MySQL 8.0	TLS 1.2, TLS 1.3	TLS 1.2

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

Herunterladen des öffentlichen SSL-Zertifikats

Wenn Sie bei Ihren Clientanwendungen verschlüsselte Verbindungen verwenden möchten, müssen Sie das öffentliche SSL-Zertifikat herunterladen, das auch im Azure-Portal im Bereich „Netzwerk“ zur Verfügung steht, wie im folgenden Screenshot gezeigt wird.

Hinweis

Sie müssen dieses SSL-Zertifikat für Ihre Server in der Azure Government-Cloud herunterladen.

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. Auf diese Weise können Anwendungen über SSL eine sichere Verbindung mit der Datenbank herstellen.

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 mysql.exe oder MySQL Workbench auswählen, um aus Ihrer lokalen Umgebung eine Verbindung mit dem Server herzustellen.

Das folgende Beispiel zeigt, wie Sie einen Server mithilfe der mysql-Befehlszeilenschnittstelle verbinden können. 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://dl.cacerts.digicert.com/DigiCertGlobalRootCA.crt.pem
mysql -h mydemoserver.mysql.database.azure.com -u mydemouser -p --ssl-mode=REQUIRED --ssl-ca=DigiCertGlobalRootCA.crt.pem

Hinweis

Vergewissern Sie sich, dass der Wert, den Sie an --ssl-ca übergeben haben, mit dem Dateipfad für das von Ihnen gespeicherte Zertifikat übereinstimmt. Wenn Sie mit SSL eine Verbindung mit der flexiblen Azure Database for MySQL herstellen und eine Option verwenden, um die vollständige Überprüfung (sslmode=VERIFY_IDENTITY) mit dem Zertifikatssubjektnamen durchzuführen, verwenden Sie <Servername>.mysql.database.azure.com in Ihrer Verbindungszeichenfolge.

Wenn Sie versuchen, mit unverschlüsselten Verbindungen eine Verbindung mit Ihrem Server herzustellen, werden Sie in einer Fehlermeldung informiert, dass Verbindungen mithilfe von unsicherem Transport nicht zulässig sind, ähnlich wie im folgenden Beispiel:

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

Überprüfen der TLS/SSL-Verbindung

Führen Sie die MySQL-Befehl status aus, um sicherzustellen, dass die Verbindung mit dem MySQL-Server über TLS/SSL hergestellt wurde:

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üsselungssammlung zeigt ein Beispiel und basierend auf dem Client können Sie eine andere Verschlüsselungssammlung sehen.

Wie identifizieren Sie die TLS-Protokolle, die auf Ihrem Server konfiguriert sind?

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

mysql> SHOW GLOBAL VARIABLES LIKE 'tls_version';

Wie ermitteln Sie, welches TLS-Protokoll von Ihren Clients verwendet wird, um eine Verbindung mit dem Server herzustellen ?

Sie können den folgenden Befehl ausführen und „tls_version“ für die Sitzung anzeigen, um festzustellen, welche TLS-Version verwendet wird, um eine Verbindung herzustellen.

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 Instanz von Azure DB for MySQL – Flexibler Server mit verschlüsselten Verbindungen mithilfe von verschiedenen Anwendungsframeworks

Entsprechend enthalten Verbindungszeichenfolgen, die im Azure-Portal unter dem Server auf der Seite „Verbindungszeichenfolgen“ vorab definiert sind, die erforderlichen Parameter für gängige Sprachen für die Verbindung mit dem Datenbankserver mithilfe von TLS/SSL. Der TLS/SSL-Parameter variiert je nach Connector. Beispiel: "useSSL=true", "sslmode=required" oder "ssl_verify_cert=true" und andere Variationen.

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 der Zeile // **MySQL settings - You can get this info from your web host** // in „wp-config.php“ ein.

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

PHP

$conn = mysqli_init();
mysqli_ssl_set($conn,NULL,NULL, "/var/www/html/DigiCertGlobalRootCA.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/DigiCertGlobalRootCA.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='yourpassword',
                                   database='quickstartdb',
                                   host='mydemoserver.mysql.database.azure.com',
                                   ssl_ca='/var/www/html/DigiCertGlobalRootCA.crt.pem')
except mysql.connector.Error as err:
    print(err)

Python (PyMySQL)

conn = pymysql.connect(user='myadmin',
                       password='yourpassword',
                       database='quickstartdb',
                       host='mydemoserver.mysql.database.azure.com',
                       ssl={'ca': '/var/www/html/DigiCertGlobalRootCA.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/DigiCertGlobalRootCA.crt.pem'}
        }
    }
}

Ruby

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

Golang

rootCertPool := x509.NewCertPool()
pem, _ := ioutil.ReadFile("/var/www/html/DigiCertGlobalRootCA.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 = "DigiCertGlobalRootCA.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/DigiCertGlobalRootCA.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;
});

Nächste Schritte

• Verwenden von MySQL Workbench zum Herstellen einer Verbindung und zum Abfragen von Daten in Azure Database for MySQL Flexible Server
• Verwenden von PHP zum Herstellen einer Verbindung und zum Abfragen von Daten in Azure Database for MySQL Flexible Server
• Erstellen und Verwalten von virtuellen Netzwerken für Azure Database for MySQL Flexible Server mit der Azure CLI
• Netzwerkkonzepte für Azure Database for MySQL – Flexible Server
• Erfahren Sie mehr über Firewallregeln für Azure Database for MySQL Flexible Server