Hinzufügen einer Amazon RDS-DB-Instance zur Java-Anwendungsumgebung - AWS Elastic Beanstalk
Herunterladen eines JDBC-TreibersVerbinden mit einer Datenbank (Java SE-Plattformen)Verbinden mit einer Datenbank (Tomcat-Plattformen)Fehlerbehebung bei Datenbankverbindungen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Hinzufügen einer Amazon RDS-DB-Instance zur Java-Anwendungsumgebung

Sie können eine Amazon Relational Database Service (Amazon RDS)-DB-Instance verwenden, um Daten zu speichern, die Ihre Anwendung sammelt und modifiziert. Die Datenbank kann Ihrer Umgebung angefügt und von Elastic Beanstalk verwaltet werden oder sie kann extern erstellt und verwaltet werden.

Bei der ersten Verwendung von Amazon RDS fügen Sie in der Testumgebung mithilfe der Elastic Beanstalk-Konsole eine DB-Instance hinzu und überprüfen, ob die Anwendung eine Verbindung zu dieser herstellen kann.

So fügen Sie eine DB-Instance zu Ihrer Umgebung hinzu

  1. Öffnen Sie die Elastic-Beanstalk-Konsole und wählen Sie in der Liste Regions (Regionen) Ihre AWS-Region aus.

  2. Wählen Sie im Navigationsbereich Environments (Umgebungen) aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

    Anmerkung

    Wenn Sie viele Umgebungen haben, verwenden Sie die Suchleiste, um die Umgebungsliste zu filtern.

  3. Wählen Sie im Navigationsbereich Configuration (Konfiguration) aus.

  4. Wählen Sie in der Konfigurationskategorie Database (Datenbank) die Option Edit (Bearbeiten).

  5. Wählen Sie eine DB-Engine aus und geben Sie Benutzernamen und Passwort ein.

  6. Wählen Sie unten auf der Seite die Option Apply (Anwenden) aus, um die Änderungen zu speichern.

Das Hinzufügen einer DB-Instance dauert ca. 10 Minuten. Sobald die Umgebungsaktualisierung abgeschlossen ist, stehen der Hostname der DB-Instance und andere Verbindungsinformationen über die folgenden Umgebungseigenschaften zur Verfügung:

Eigenschaftenname Beschreibung Eigenschaftenwert

RDS_HOSTNAME

Der Hostname der DB-Instance.

Auf der Registerkarte Connectivity & security (Konnektivität und Sicherheit) in der Amazon RDS-Konsole: Endpoint (Endpunkt).

RDS_PORT

Der Port, über den die DB-Instance Verbindungen annimmt. Die DB-Engines haben unterschiedliche Standardwerte.

Auf der Registerkarte Connectivity & security (Konnektivität und Sicherheit) auf der Amazon RDS-Konsole: Port.

RDS_DB_NAME

Der Datenbanknam, ebdb.

Auf der Registerkarte Configuration (Konfiguration) der Amazon RDS-Konsole: DB-Name.

RDS_USERNAME

Der Benutzername, der für die Datenbank konfiguriert wurde.

Auf der Registerkarte Configuration (Konfiguration) in der Amazon RDS-Konsole: Master username (Master-Benutzername).

RDS_PASSWORD

Das Passwort, das für die Datenbank konfiguriert wurde.

In der Amazon RDS-Konsole nicht als Referenz verfügbar.

Weitere Informationen zum Konfigurieren einer internen DB-Instance finden Sie unter Hinzufügen einer Datenbank zu Ihrer Elastic Beanstalk-Umgebung. Anweisungen zum Konfigurieren einer externen Datenbank für die Verwendung mit Elastic Beanstalk finden Sie unter Verwenden von Elastic Beanstalk mit Amazon RDS.

Für die Verbindungserstellung zu einer Datenbank fügen Sie die geeignete JAR-Treiberdatei zur Anwendung hinzu, laden die Klasse in den Code und erstellen ein Verbindungsobjekt mit den von Elastic Beanstalk bereitgestellten Umgebungseigenschaften.

Herunterladen eines JDBC-Treibers

Sie benötigen die JAR-Datei des JDBC-Treibers für die DB-Engine, die Sie gewählt haben. Speichern Sie die JAR-Datei in Ihrem Quellcode und fügen Sie sie in Ihren Klassenpfad ein, wenn Sie die Klasse kompilieren, die Verbindungen mit der Datenbank herstellt.

Die neuesten Treiber für Ihre DB-Engine finden Sie an den folgenden Speicherorten:

Um den JDBC-Treiber zu verwenden, rufen Sie Class.forName() auf, um ihn zu laden, bevor Sie die Verbindung mit DriverManager.getConnection() in Ihrem Code herstellen.

JDBC verwendet eine Verbindungszeichenfolge mit folgendem Format:

jdbc:driver://hostname:port/dbName?user=userName&password=password

Sie können den Hostnamen, Port, Datenbanknamen, Benutzernamen und das Passwort von den Umgebungsvariablen abrufen, die Elastic Beanstalk für Ihre Anwendung bereitstellt. Der Treibername ist spezifisch für Ihren Datenbanktyp und Ihre Treiberversion. Es folgen Beispiele für Treibernamen:

  • mysql for MySQL

  • postgresql for PostgreSQL

  • oracle:thin for Oracle Thin

  • oracle:oci for Oracle OCI

  • oracle:oci8 for Oracle OCI 8

  • oracle:kprb for Oracle KPRB

  • sqlserver for SQL Server

Verbinden mit einer Datenbank (Java SE-Plattformen)

In einer Java SE-Umgebung verwenden Sie System.getenv(), um die Verbindungsvariablen aus der Umgebung zu lesen. Der folgende Beispielcode zeigt eine Klasse, die eine Verbindung zu einer PostgreSQL-Datenbank erstellt.

private static Connection getRemoteConnection() {
    if (System.getenv("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getenv("RDS_DB_NAME");
      String userName = System.getenv("RDS_USERNAME");
      String password = System.getenv("RDS_PASSWORD");
      String hostname = System.getenv("RDS_HOSTNAME");
      String port = System.getenv("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }

Verbinden mit einer Datenbank (Tomcat-Plattformen)

In einer Tomcat-Umgebung werden Umgebungseigenschaften als Systemeigenschaften bereitgestellt, die mit zugreifbar sin System.getProperty().

Der folgende Beispielcode zeigt eine Klasse, die eine Verbindung zu einer PostgreSQL-Datenbank erstellt.

private static Connection getRemoteConnection() {
    if (System.getProperty("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getProperty("RDS_DB_NAME");
      String userName = System.getProperty("RDS_USERNAME");
      String password = System.getProperty("RDS_PASSWORD");
      String hostname = System.getProperty("RDS_HOSTNAME");
      String port = System.getProperty("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }

Wenn Sie Probleme haben, eine Verbindung herzustellen oder SQL-Anweisungen auszuführen, versuchen Sie, den folgenden Code in einer JSP-Datei zu platzieren. Dieser Code stellt eine Verbindung zu einer DB-Instance her, erstellt eine Tabelle und schreibt in sie.

<%@ page import="java.sql.*" %>
<%
  // Read RDS connection information from the environment
  String dbName = System.getProperty("RDS_DB_NAME");
  String userName = System.getProperty("RDS_USERNAME");
  String password = System.getProperty("RDS_PASSWORD");
  String hostname = System.getProperty("RDS_HOSTNAME");
  String port = System.getProperty("RDS_PORT");
  String jdbcUrl = "jdbc:mysql://" + hostname + ":" +
    port + "/" + dbName + "?user=" + userName + "&password=" + password;
  
  // Load the JDBC driver
  try {
    System.out.println("Loading driver...");
    Class.forName("com.mysql.jdbc.Driver");
    System.out.println("Driver loaded!");
  } catch (ClassNotFoundException e) {
    throw new RuntimeException("Cannot find the driver in the classpath!", e);
  }

  Connection conn = null;
  Statement setupStatement = null;
  Statement readStatement = null;
  ResultSet resultSet = null;
  String results = "";
  int numresults = 0;
  String statement = null;

  try {
    // Create connection to RDS DB instance
    conn = DriverManager.getConnection(jdbcUrl);
    
    // Create a table and write two rows
    setupStatement = conn.createStatement();
    String createTable = "CREATE TABLE Beanstalk (Resource char(50));";
    String insertRow1 = "INSERT INTO Beanstalk (Resource) VALUES ('EC2 Instance');";
    String insertRow2 = "INSERT INTO Beanstalk (Resource) VALUES ('RDS Instance');";
    
    setupStatement.addBatch(createTable);
    setupStatement.addBatch(insertRow1);
    setupStatement.addBatch(insertRow2);
    setupStatement.executeBatch();
    setupStatement.close();
    
  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
    System.out.println("Closing the connection.");
    if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }

  try {
    conn = DriverManager.getConnection(jdbcUrl);
    
    readStatement = conn.createStatement();
    resultSet = readStatement.executeQuery("SELECT Resource FROM Beanstalk;");

    resultSet.first();
    results = resultSet.getString("Resource");
    resultSet.next();
    results += ", " + resultSet.getString("Resource");
    
    resultSet.close();
    readStatement.close();
    conn.close();

  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
       System.out.println("Closing the connection.");
      if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }
%>

Zum Anzeigen der Ergebnisse platzieren Sie den folgenden Code im Text des HTML-Teils der JSP-Datei.

<p>Established connection to RDS. Read first two rows: <%= results %></p>

Fehlerbehebung bei Datenbankverbindungen

Wenn Sie auf Probleme mit der Verbindung zu einer Datenbank über Ihre Anwendung stoßen, überprüfen Sie das Web-Container-Protokoll und die Datenbank.

Überprüfen von Protokollen

Sie können alle Protokolle aus Ihrer Elastic Beanstalk-Umgebung in Eclipse anzeigen. Wenn Sie die AWS Explorer-Ansicht nicht geöffnet haben, wählen Sie den Pfeil neben dem orangefarbenen AWSSymbol in der Menüleiste und wählen Sie Show AWSExplorer View. Erweitern Sie AWS Elastic Beanstalk und Ihren Umgebungsnamen und öffnen Sie dann das Kontextmenü (rechte Maustaste) für den Server. Klicken Sie auf Open in WTP Server Editor.

Wählen Sie die Registerkarte Log der Server-Ansicht, um die aggregierten Protokolle aus Ihrer Umgebung zu sehen. Um die neuesten Protokolle zu öffnen, wählen Sie die Schaltfläche Refresh oben rechts auf der Seite.

Scrollen Sie nach unten, um die Tomcat-Protokolle in zu suche /var/log/tomcat7/catalina.out. Wenn Sie die Webseite aus unserem oben stehenden Beispiel mehrmals geladen haben, sehen Sie möglicherweise Folgendes: 

-------------------------------------
/var/log/tomcat7/catalina.out
-------------------------------------
INFO: Server startup in 9285 ms
Loading driver...
Driver loaded!
SQLException: Table 'Beanstalk' already exists
SQLState: 42S01
VendorError: 1050
Closing the connection.
Closing the connection.

Alle Informationen, die die Webanwendung an die Standardausgabe sendet, wird im Web-Container-Protokoll angezeigt. Im vorherigen Beispiel versucht die Anwendung, die Tabelle jedes Mal zu erstellen, wenn die Seite geladen wird. Dies führt zur Erfassung einer SQL-Ausnahme auf jeder Seite, die nach der ersten geladen wird.

Beispielsweise ist die vorhergehende akzeptabel. Aber in tatsächlichen Anwendungen behalten Sie Ihre Datenbankdefinitionen in Schemaobjekten, führen Transaktionen in Modellklassen durch und koordinieren Anforderungen mit Controller-Servlets.

Herstellen einer Verbindung mit einer RDS DB-Instance

Sie können eine direkte Verbindung zur RDS DB-Instance in Ihrer Elastic Beanstalk-Umgebung herstellen, indem Sie die MySQL-Client-Anwendung verwenden.

Öffnen Sie zunächst die Sicherheitsgruppe für Ihre RDS DB-Instance, um Datenverkehr von Ihrem Computer zuzulassen.

  1. Öffnen Sie die Elastic-Beanstalk-Konsole und wählen Sie in der Liste Regions (Regionen) Ihre AWS-Region aus.

  2. Wählen Sie im Navigationsbereich Environments (Umgebungen) aus und wählen Sie dann in der Liste den Namen Ihrer Umgebung aus.

    Anmerkung

    Wenn Sie viele Umgebungen haben, verwenden Sie die Suchleiste, um die Umgebungsliste zu filtern.

  3. Wählen Sie im Navigationsbereich Configuration (Konfiguration) aus.

  4. Wählen Sie in der Konfigurationskategorie Database (Datenbank) die Option Edit (Bearbeiten).

  5. Wählen Sie neben Endpoint (Endpunkt) den Link zur Amazon RDS-Konsole aus.

  6. Wählen Sie auf der Detailseite der RDS Dashboard-Instance unter Security and Network die Sicherheitsgruppe beginnend mit rds- neben Security Groups.

    Anmerkung

    Die Datenbank kann über mehrere Einträge mit der Bezeichnung Security Groups verfügen. Wenn Sie ein älteres Konto haben, das nicht standardmäßig über Amazon Virtual Private Cloud (Amazon VPC) verfügt, verwenden Sie die erste, die mit awseb beginnt.

  7. Rufen Sie in Security group details die Registerkarte Inbound auf und klicken Sie auf Edit.

  8. Fügen Sie eine Regel für MySQL (Port 3306) hinzu, die Datenverkehr von Ihrer IP-Adresse erlaubt, angegeben im CIDR-Format.

  9. Wählen Sie Save aus. Die Änderungen werden sofort wirksam.

Kehren Sie zu den Elastic Beanstalk-Konfigurationsdetails für Ihre Umgebung zurück und beachten Sie den Endpunkt. Sie verwenden den Domänennamen für die Verbindung mit der RDS-DB-Instance.

Installieren Sie den MySQL-Client und initiieren Sie eine Verbindung mit der Datenbank auf Port 3306. Installieren Sie unter Windows MySQL Workbench von der MySQL-Startseite und befolgen Sie die Anweisungen.

Installieren Sie unter Linux den MySQL-Client mithilfe des Paket-Managers für Ihre Verteilung. Das folgende Beispiel funktioniert auf Ubuntu und anderen Debian-Derivaten. 

// Install MySQL client
$ sudo apt-get install mysql-client-5.5
...
// Connect to database
$ mysql -h aas839jo2vwhwb.cnubrrfwfka8.us-west-2.rds.amazonaws.com -u username -ppassword ebdb
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 117
Server version: 5.5.40-log Source distribution
...

Nachdem Sie eine Verbindung hergestellt haben, können Sie SQL-Befehle ausfehlen, um den Status der Datenbank, unabhängig davon, ob Ihre Tabellen und Zeilen erstellt wurden, und andere Informationen anzuzeigen. 

mysql> SELECT Resource from Beanstalk;
+--------------+
| Resource     |
+--------------+
| EC2 Instance |
| RDS Instance |
+--------------+
2 rows in set (0.01 sec)