As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Adicionar uma instância de banco de dados do Amazon RDS ao seu ambiente Java Elastic Beanstalk
<a name="java-rds"></a>

Este tópico fornece instruções para criar o Amazon RDS usando o console do Elastic Beanstalk. É possível usar uma instância de banco de dados do Amazon Relational Database Service (Amazon RDS) para armazenar dados coletados e modificados pela aplicação. O banco de dados pode ser anexado ao seu ambiente e gerenciado pelo Elastic Beanstalk ou criado e gerenciado externamente.

Se você estiver usando o Amazon RDS pela primeira vez, adicione uma instância de banco de dados a um ambiente de teste utilizando o console do Elastic Beanstalk e verifique se a aplicação pode se conectar a ele. 

**Para adicionar uma instância de banco de dados ao ambiente**

1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS

1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.

1. No painel de navegação, escolha **Configuration (Configuração)**.

1. Na categoria de configuração **Database (Banco de dados)**, escolha **Edit (Editar)**.

1. Escolha um mecanismo de banco de dados e insira um nome de usuário e senha.

1. Para salvar as alterações, escolha **Apply (Aplicar)** na parte inferior da página.

A adição de uma instância de banco de dados leva cerca de 10 minutos. Quando a atualização do ambiente for concluída, o nome de host da instância de banco de dados e outras informações de conexão estarão disponíveis para o seu aplicativo por meio das seguintes propriedades de ambiente:


| Nome da propriedade | Descrição | Valor da propriedade | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  O nome do host da instância de banco de dados.  |  Na guia **Connectivity & security (Conectividade e segurança)** no console do Amazon RDS: **Endpoint**.  | 
|  `RDS_PORT`  |  A porta na qual a instância de banco de dados aceita conexões. O valor padrão varia entre os mecanismos de banco de dados.  |  Na guia **Connectivity & security (Conectividade e segurança)** do console do Amazon RDS: **Port (Porta)**.  | 
|  `RDS_DB_NAME`  |  O nome do banco de dado, **ebdb**.  |  Na guia **Configuration (Configuração)** no console do Amazon RDS: **DB Name (Nome do banco de dados)**.  | 
|  `RDS_USERNAME`  |  O nome de usuário que você configurou para seu banco de dados.  |  Na guia **Configuration (Configuração)** do console do Amazon RDS: **Nome de usuário primário**.  | 
|  `RDS_PASSWORD`  |  A senha que você configurou para seu banco de dados.  |  Não disponível para referência no console do Amazon RDS.  | 

Para obter mais informações sobre como configurar uma instância de banco de dados interna, consulte [Adição de um banco de dados ao seu ambiente do Elastic Beanstalk](using-features.managing.db.md). Para obter instruções sobre como configurar um banco de dados externo para uso com o Elastic Beanstalk, consulte [Usar o Elastic Beanstalk com o Amazon RDS](AWSHowTo.RDS.md).

Para se conectar ao banco de dados, adicione o arquivo JAR do driver adequado à sua aplicação, carregue a classe do driver no seu código e crie um objeto de conexão com as propriedades de ambiente fornecidas pelo Elastic Beanstalk.

**Topics**
+ [Fazer download do driver do JDBC](#java-rds-drivers)
+ [Conectar a um banco de dados (plataformas Java SE)](#java-rds-javase)
+ [Conectar a um banco de dados (plataformas Tomcat)](#java-rds-tomcat)
+ [Solução de problemas de conexões do banco de dados](#create_deploy_Java.rds.troubleshooting)

## Fazer download do driver do JDBC
<a name="java-rds-drivers"></a>

Você precisará do arquivo JAR do driver JDBC para o mecanismo de banco de dados escolhido. Salve o arquivo JAR em seu código-fonte e o inclua em seu classpath quando você compilar a classe que cria conexões com o banco de dados.

Você pode encontrar o driver mais recente para o seu mecanismo de banco de dados nos seguintes locais:
+ **MySQL**: [MySQL Connector/J](https://dev.mysql.com/downloads/connector/j/)
+ **Oracle SE-1**: [Oracle JDBC Driver](http://www.oracle.com/technetwork/database/features/jdbc/index-091264.html)
+ **Postgres**: [PostgreSQL JDBC Driver](https://jdbc.postgresql.org/)
+ **SQL Server**: [Microsoft JDBC Driver](https://msdn.microsoft.com/en-us/sqlserver/aa937724.aspx)

Para usar o driver JDBC, chame `Class.forName()` para carregá-lo antes de criar a conexão com `DriverManager.getConnection()` em seu código.

O JDBC usa uma string de conexão no seguinte formato:

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

É possível recuperar o nome do host, a porta, o nome do banco de dados, o nome de usuário e a senha das variáveis de ambiente que o Elastic Beanstalk fornece à aplicação. O nome do driver é específico do tipo de banco de dados e da versão do driver. Os exemplos a seguir são de nomes de driver:
+ `mysql` para MySQL
+ `postgresql` para PostgreSQL
+ `oracle:thin` para Oracle Thin
+ `oracle:oci` para Oracle OCI
+ `oracle:oci8` para Oracle OCI 8
+ `oracle:kprb` para Oracle KPRB
+ `sqlserver` para SQL Server

## Conectar a um banco de dados (plataformas Java SE)
<a name="java-rds-javase"></a>

Em um ambiente Java SE, use `System.getenv()` para ler as variáveis de conexão do ambiente. O exemplo de código a seguir mostra uma classe que cria uma conexão com um banco de dados PostgreSQL.

```
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;
  }
```

## Conectar a um banco de dados (plataformas Tomcat)
<a name="java-rds-tomcat"></a>

Em um ambiente Tomcat, as propriedades do ambiente são fornecidas como propriedades do sistema que podem ser acessadas com `System.getProperty()`.

O exemplo de código a seguir mostra uma classe que cria uma conexão com um banco de dados PostgreSQL.

```
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;
  }
```

Se você tiver problemas para obter uma conexão ou executar instruções SQL, coloque o código a seguir em um arquivo JSP. Esse código conecta a uma instância de banco de dados, cria uma tabela e grava nela.

```
<%@ 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) {}
  }
%>
```

Para exibir os resultados, coloque o seguinte código no corpo da parte HTML do arquivo JSP.

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

## Solução de problemas de conexões do banco de dados
<a name="create_deploy_Java.rds.troubleshooting"></a>

**Experimente a Amazon Q Developer CLI para solução de problemas assistida por IA**  
 A Amazon Q Developer CLI pode ajudar a solucionar problemas de ambiente rapidamente. A Q CLI fornece soluções verificando o status do ambiente, analisando eventos, analisando logs e fazendo perguntas esclarecedoras. Para obter mais informações e orientações detalhadas, consulte Solução de problemas de [ambientes do Elastic Beanstalk com o Amazon](https://aws.amazon.com/blogs/devops/troubleshooting-elastic-beanstalk-environments-with-amazon-q-developer-cli/) Q Developer CLI nos blogs. AWS 

Se você tiver problemas para se conectar a um banco de dados a partir do seu aplicativo, revise o banco de dados e o log do contêiner da web.

### Revisar logs
<a name="create_deploy_Java.rds.troubleshooting.logs"></a>

É possível visualizar todos os logs do seu ambiente do Elastic Beanstalk a partir do Eclipse. Se você não tiver a exibição do AWS Explorer aberta, escolha a seta ao lado do AWS ícone laranja na barra de ferramentas e escolha **Mostrar exibição do AWS Explorer**. Expanda **AWS Elastic Beanstalk** e o nome do seu ambiente, em seguida, abra o menu de contexto (clique com o botão direito do mouse) do servidor. Escolha **Open in WTP Server Editor**. 

 Escolha a guia **Log** da visualização **Server** para ver os logs agregados do ambiente. Para abrir os logs mais recentes, escolha o botão **Refresh** no canto superior direito da página. 

 Role para baixo para localizar os logs do Tomcat em `/var/log/tomcat7/catalina.out`. Se você carregou a página da web do exemplo anterior várias vezes, talvez veja o seguinte. 

```
-------------------------------------
/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.
```

Todas as informações que o aplicativo web envia para a saída padrão aparecem no log do contêiner da web. No exemplo anterior, o aplicativo tenta criar a tabela sempre que a página carrega. Isso resulta na detecção de uma exceção SQL em cada carregamento de página após o primeiro. 

Como exemplo, o antecedente é aceitável. Mas em aplicativos reais, mantenha suas definições de banco de dados em objetos de esquema, execute transações de dentro de classes do modelo e coordene solicitações com servlets de controlador.

### Conectar a uma instância de banco de dados do RDS
<a name="create_deploy_Java.rds.troubleshooting.connecting"></a>

 É possível se conectar diretamente à instância de banco de dados do RDS no seu ambiente do Elastic Beanstalk usando a aplicação cliente MySQL. 

 Primeiro, abra o security group de sua instância de banco de dados do RDS para permitir o tráfego de seu computador. 

1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS

1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.

1. No painel de navegação, escolha **Configuration (Configuração)**.

1. Na categoria de configuração **Database (Banco de dados)**, escolha **Edit (Editar)**.

1. Ao lado de **Endpoint**, escolha o link do console do Amazon RDS.

1. Na página de detalhes da instância **RDS Dashboard**, em **Security and Network**, escolha o security group que começa com *rds-* ao lado de **Security Groups**.
**nota**  
O banco de dados pode ter várias entradas com o rótulo **Security Groups**. Use o primeiro, que começa com *awseb*, somente se você tiver uma conta antiga que não tenha uma [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) padrão.

1. Em **Security group details**, escolha a guia **Inbound** e, em seguida, **Edit**.

1. Adicione uma regra para MySQL (porta 3306) que permita o tráfego de seu endereço IP, especificado no formato CIDR.

1. Escolha **Save (Salvar)**. As alterações entram em vigor imediatamente.

 Retorne aos detalhes de configuração do Elastic Beanstalk do seu ambiente e observe o endpoint. Você usará o nome de domínio para se conectar à instância de banco de dados do RDS. 

 Instale o cliente MySQL e inicie uma conexão com o banco de dados na porta 3306. No Windows, instale o MySQL Workbench a partir da página inicial do MySQL e siga as instruções. 

 No Linux, instale o cliente MySQL usando o gerenciador de pacote para sua distribuição. O exemplo a seguir funciona no Ubuntu e em outros derivados de Debian. 

```
// 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
...
```

Depois de conectado, execute comandos SQL para ver o status do banco de dados, verificar se suas tabelas e linhas foram criadas e outras informações. 

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