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 zu Ihrer Java Elastic Beanstalk Beanstalk-Umgebung

Dieses Thema enthält Anweisungen zum Erstellen eines Amazon RDS mit der Elastic-Beanstalk-Konsole. 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.

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:

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:

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, klicken Sie auf den Pfeil neben dem orangefarbenen AWS Symbol in der Werkzeugleiste und wählen Sie dann AWS Explorer-Ansicht anzeigen. 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.

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)