Amazon RDS For mysql And Amazon RDS For Aurora
直接上demo：
配置文件：
server:
port: 8889
spring:
datasource:
master:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://auroradatasource.cluster-cjhlzjielcdr.us-west-2.rds.amazonaws.com:3306/aurora_test1?characterEncoding=utf8&useSSL=false
username: ****
password: ****
max-idle: 10
max-wait: 10000
min-idle: 5
max-active: 10
initial-size: 5
validation-query: SELECT 1
test-on-borrow: false
test-while-idle: true
time-between-eviction-runs-millis: 18800
slave:
url: jdbc:mysql://auroradatasource.cluster-ro-cjhlzjielcdr.us-west-2.rds.amazonaws.com/aurora_test1?characterEncoding=utf8&useSSL=false
username: admin
password: admin123
driver-class-name: com.mysql.jdbc.Driver
pom文件：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.8.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.tcl</groupId>
<artifactId>amazondemo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>amazondemo</name>
<packaging>pom</packaging>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
<version>5.1.46</version>
</dependency>
<dependency>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-core</artifactId>
<version>1.3.5</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.2.2</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.0</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.8.2</version>
</dependency>
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.11</version>
</dependency>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-java-sdk</artifactId>
<version>1.11.431</version>
</dependency>
<!--<dependency>-->
<!--<groupId>com.amazonaws</groupId>-->
<!--<artifactId>DynamoDBLocal</artifactId>-->
<!--<version>[1.11,2.0)</version>-->
<!--</dependency>-->
</dependencies>
<!--Custom repository:-->
<!--<repositories>-->
<!--<repository>-->
<!--<id>dynamodb-local-oregon</id>-->
<!--<name>DynamoDB Local Release Repository</name>-->
<!--<url>https://s3-us-west-2.amazonaws.com/dynamodb-local/release</url>-->
<!--</repository>-->
<!--</repositories>-->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
pojo
package com.tcl.amazondemo.pojo;
import java.io.Serializable;
/**
* @ClassName PersonEntity
* @Description TODO
* @Author youzp
* @Date 2019/9/17 16:28
* @Version 1.0
**/
public class PersonEntity implements Serializable {
private static final long serialVersionUID = -1L;
private String name;
private String age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
controller层
package com.tcl.amazondemo.controller;
import com.tcl.amazondemo.mapper.AmazonTestMapper;
import com.tcl.amazondemo.pojo.PersonEntity;
import com.tcl.amazondemo.service.AmazonTestServer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @ClassName AmazonTestController
* @Description TODO
* @Author youzp
* @Date 2019/9/17 16:29
* @Version 1.0
**/
@RestController
@RequestMapping(value = "/test")
public class AmazonTestController {
@Autowired
AmazonTestServer amazonTestServer;
@RequestMapping(value = "send", method = RequestMethod.POST)
public List<PersonEntity> bindingDevice(){
List<PersonEntity> personEntityList = amazonTestServer.queryPersionList();
return personEntityList;
}
}
server层
package com.tcl.amazondemo.service;
import com.tcl.amazondemo.pojo.PersonEntity;
import java.util.List;
public interface AmazonTestServer {
List<PersonEntity> queryPersionList();
}
package com.tcl.amazondemo.service;
import com.tcl.amazondemo.mapper.AmazonTestMapper;
import com.tcl.amazondemo.pojo.PersonEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @ClassName AmazonTestServerImpl
* @Description TODO
* @Author youzp
* @Date 2019/9/18 13:48
* @Version 1.0
**/
@Service
public class AmazonTestServerImpl implements AmazonTestServer {
@Autowired
AmazonTestMapper amazonTestMapper;
@Override
public List<PersonEntity> queryPersionList() {
PersonEntity personEntity = new PersonEntity();
personEntity.setAge("100");
personEntity.setName("jy");
amazonTestMapper.queryPersionList(personEntity);
// return amazonTestMapper.queryPersionList();
return null;
}
}
mapper
package com.tcl.amazondemo.mapper;
import com.tcl.amazondemo.mysql.DataSource;
import com.tcl.amazondemo.pojo.PersonEntity;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* @ClassName AmazonTestMapper
* @Description TODO
* @Author youzp
* @Date 2019/9/18 13:49
* @Version 1.0
**/
//@Repository
public interface AmazonTestMapper {
@DataSource("slave")
@Insert("insert into company(name,age1)values(#{name},#{age})")
// @Select("select * from company")
Integer queryPersionList(PersonEntity personEntity);
}
主从数据库配置
package com.tcl.amazondemo.mysql;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface DataSource {
String value();
}
package com.tcl.amazondemo.mysql;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import java.lang.reflect.Method;
public class DataSourceAspect {
private static Log log = LogFactory.getLog(DataSourceAspect.class);
public DataSourceAspect() {
}
public void before(JoinPoint point) {
Object target = point.getTarget();
String method = point.getSignature().getName();
try {
Class<?>[] classz = target.getClass().getInterfaces();
if (null != classz && classz.length > 0) {
Class<?>[] parameterTypes = ((MethodSignature)point.getSignature()).getMethod().getParameterTypes();
Method m = classz[0].getMethod(method, parameterTypes);
if (m != null && m.isAnnotationPresent(DataSource.class)) {
DataSource data = (DataSource)m.getAnnotation(DataSource.class);
DynamicDataSourceHolder.clearDataSource();
DynamicDataSourceHolder.putDataSource(data.value());
}
}
} catch (Exception var8) {
var8.printStackTrace();
log.error(var8.getMessage(), var8);
}
}
}
package com.tcl.amazondemo.mysql;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component
@Aspect
public class DataSourceAspectAop {
private static Log log = LogFactory.getLog(DataSourceAspectAop.class);
// @Pointcut(value = "execution(* com.tcl.amazondemo..mapper.*.*(..))")
@Pointcut(value = "execution(* com.tcl.amazondemo..mapper.*.*(..))")
public void dataSourceAspect() {
}
@Resource(name = "dynamicDataSourceAspect")
DataSourceAspect dynamicDataSourceAspect;
/**
* 拦截@DataSource注解用来选择主从库
*
* @param point
*/
@Before(value = "dataSourceAspect()")
public void before(JoinPoint point) {
dynamicDataSourceAspect.before(point);
}
}
package com.tcl.amazondemo.mysql;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
public class DynamicDataSource extends AbstractRoutingDataSource {
public DynamicDataSource() {
}
@Override
protected Object determineCurrentLookupKey() {//3
String source= DynamicDataSourceHolder.getDataSouce();
return source;//1//3
}
}
package com.tcl.amazondemo.mysql;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class DynamicDataSourceHolder {
private static Log log = LogFactory.getLog(DynamicDataSourceHolder.class);
public static final ThreadLocal<String> holder = new ThreadLocal();
public DynamicDataSourceHolder() {
}
public static void putDataSource(String name) {
holder.set(name);
}
public static String getDataSouce() {//2
String hhost = holder.get();
return hhost;
}
public static void clearDataSource() {
holder.remove();
}
}
package com.tcl.amazondemo.mysql;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.annotation.Resource;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class JdbcConfig {
@Value("${spring.datasource.master.driver-class-name}")
private String driverClassName;
/**
* 主库配置
*/
@Value("${spring.datasource.master.username}")
private String masterUsername;
@Value("${spring.datasource.master.password}")
private String masterPassword;
@Value("${spring.datasource.master.url}")
private String masterUrl;
/**
* 从库配置
*
* @return
* @throws SQLException
*/
@Value("${spring.datasource.slave.username}")
private String slaveUsername;
@Value("${spring.datasource.slave.password}")
private String slavePassword;
@Value("${spring.datasource.slave.url}")
private String slaveUrl;
public DruidDataSource parentDataSource() {
DruidDataSource parentDataSource = new DruidDataSource();
try {
parentDataSource.setDriverClassName(driverClassName);
parentDataSource.setMaxActive(200);
parentDataSource.setInitialSize(20);
parentDataSource.setMaxWait(60000);
parentDataSource.setMinIdle(1);
parentDataSource.setTimeBetweenEvictionRunsMillis(3000);
parentDataSource.setMinEvictableIdleTimeMillis(300000);
parentDataSource.setValidationQuery("SELECT 'x' FROM DUAL");
parentDataSource.setTestWhileIdle(true);
parentDataSource.setTestOnBorrow(false);
parentDataSource.setTestOnReturn(false);
parentDataSource.setFilters("stat");
} catch (SQLException e) {
if (parentDataSource != null) {
parentDataSource.close();
}
}
return parentDataSource;
}
@Bean
@Primary
@Qualifier("masterDataSource")
@Resource(name = "parentDataSource")
public DruidDataSource masterDataSource() {
DruidDataSource parentDataSource = parentDataSource();
parentDataSource.setUrl(masterUrl);
parentDataSource.setPassword(masterPassword);
parentDataSource.setUsername(masterUsername);
return parentDataSource;
}
@Bean
@Qualifier("slaveDataSource")
@Resource(name = "parentDataSource")
public DruidDataSource slaveDataSource() {
DruidDataSource parentDataSource = parentDataSource();
parentDataSource.setUrl(slaveUrl);
parentDataSource.setPassword(slavePassword);
parentDataSource.setUsername(slaveUsername);
return parentDataSource;
}
@Bean
@Autowired
public DynamicDataSource dataSource(@Qualifier("slaveDataSource") DruidDataSource slaveDataSource, @Qualifier("masterDataSource") DruidDataSource masterDataSource) {
Map<Object, Object> stringObjectHashMap = new HashMap<>();
stringObjectHashMap.put("slave", slaveDataSource);
stringObjectHashMap.put("master", masterDataSource);
DynamicDataSource dataSource = new DynamicDataSource();
dataSource.setTargetDataSources(stringObjectHashMap);
dataSource.setDefaultTargetDataSource(masterDataSource);
return dataSource;
}
@Bean
@Autowired
public DataSourceTransactionManager transactionManager(@Qualifier("masterDataSource")DruidDataSource masterDataSource) {
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(masterDataSource);
return transactionManager;
}
}
package com.tcl.amazondemo.mysql;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import java.io.IOException;
@Configuration
public class MybaitsConfig {
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DynamicDataSource dataSource) throws IOException {
SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
sqlSessionFactory.setDataSource(dataSource);
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
sqlSessionFactory.setMapperLocations(resolver.getResources("classpath:mapper/**/*.xml"));
return sqlSessionFactory;
}
@Bean
@Scope("prototype")
public SqlSessionTemplate sqlsessionTemplate(SqlSessionFactory sqlSessionFactory) {
return new SqlSessionTemplate(sqlSessionFactory);
}
@Bean
public MapperScannerConfigurer mapperScannerConfigurer() {
MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
mapperScannerConfigurer.setBasePackage("com.tcl.amazondemo.**.mapper");
mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
return mapperScannerConfigurer;
}
@Bean
public DataSourceAspect dynamicDataSourceAspect() {
return new DataSourceAspect();
}
}
资源resource中
mapper文件下：AuthMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tcl.amazondemo.mapper.AmazonTestMapper">
<!--<resultMap id="findDeviceNetWorkMap" type="com.tcl.amazondemo.pojo.PersonEntity">-->
<!--<result column="age" jdbcType="VARCHAR" property="age"/>-->
<!--<result column="name1" jdbcType="VARCHAR" property="name"/>-->
<!--</resultMap>-->
<!--<select id="queryPersionList" resultMap="findDeviceNetWorkMap">-->
<!--select age,name1 from company-->
<!--</select>-->
</mapper>
文档说明：
- Amazon RDS 可以管理备份、软件修补、自动故障检测和恢复；
- 托管服务体验，Amazon RDS 不允许通过 shell 访问数据库实例，而仅限访问某些需要高级特权
的系统过程和表。
Amazon RDS 的基本构建基块是数据库实例，数据库实例是在云中运行的独立数据库环境，
和（AWS架构师)的对话
我问：当 MySQL是多例的是我们是直接改配置文件连接，还是通过API的方式连接
高工答：rds for mysql,如果开启了多可用区部署，他是在两个可用区部署两个实例。 你连接同一个 endpoint就可以了 ，如果出现故障会自动切换 你应用程序无需修改，这个[链接][https://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/USER_ConnectToInstance.html] 你看那一页就可以找到需要连接的endpoint了
我问：意思说不管是否为单例或者多可用部署，我们这边连接都一样的？
高工答：这个是多可用区部署的情况，连接是一样的。如果你们创建只读副本 那么还有只读副本的endpoint 需要连接。你们mysql 用什么版本 如果是5.6/5.7 我们建议用 rds for aurora 兼容mysql 引擎 性能是 mysql 数倍；使用 Aurora 来替代，以后扩展性更强 ，性能回更好。
我答：目前暂时用mysql上手快，aurora 还没有实践过；
我问：目前我已经在Amazon上创建数据库，那用数据库工具SQLyog可以连接吗？
高工答：可以的，你可以理解 Aurora 就是等同于Mysql 请看[链接][https://blog.sqlyog.com/manage-amazon-aurora-databases-sqlyog/]
我问：
好像连不上啊，哪里没有填对吗/
高工答：你在本地连接？ RDS 的安全组开放了本地ip 了么？
我答：RDS 的安全组没有开放了本地ip
在哪里开放本地IP呢？文档中没有介绍；
高工答：默认是没有开放的，你如果需要 要添加一下。 点击 default 那个安全组 进去就可以添加了；
一般默认 我们不会从本地去访问 数据库的 为了安全原因，生成环境一般 RDS 都会放在内网 基本上不会本地连接生产数据库。
我问：
是这个添加吗？
高工答：你可以在 defalut 那个安全组里面添加会比较简单，你新创建一个 需要把这个新创建的再关联到 RDS 上面；端口要写3306
我问：
现在我在修改default的，入站，出站都要改吗
高工答：添加一个 入站，出站不用改
我问：
这里注意 需要别人也访问你创建的数据库需要增加访问的IP
就这样可以吗？
高工答：可以，安全起见，不建议 开放全部端口，只开放 3306 端口就好了。因为 这个安全组 可能还会用在其它服务上；
最终修改为：
我问：我现在已经完成单例Mysql数据库模拟并形成文档，那我想让它扩展为多可用区部署该怎么做到呢？
高工答：修改 RDS 的配置就可以了，选中实例然后点修改
我问：多可用区它只是一个数据的备份吗？高工答：创建多可用区，会在另外一个可用区有一个 standby 的实例，正常情况下看不到，只有故障发生的时候自动切换；
我问：意思是说它不是横向扩展？
高工答：RDS 是关系型数据库，没办法做横向扩展。 通常的做法是 1个主库，多个自动从库。 读写分离。
我问：我有看到这样一个话 “高可用性功能不是面向只读情况的扩展解决方案；不能使用备用副本处理读取流量。要处理只读流量，应当使用只读副本；“
感觉这个只读副本创建是必要的，它类似于我们数据库中的从库吗（只不过这个只能读）我这个理解对吗？高工答：对的你的理解没错，如果 Aurora 的话，它的备用实例 是可以读的， RDS for mysql 备用实例 不可见。所以说 Aurora 其实会是一个更好的选择，
我问： Aurora用到一定时候要收费的吧，我不能做这个决定，要评估
高工答：都是要收费，Aurora 其实总体成本更低；
我问：Aurora 它的使用跟Mysql一样吗，包括引入的JAR包？
高工答：一模一样，所有重型关系型数据库客户都是 选Aurora；
我问：Aurora是对Mysql封装了一层吧
高工答：是的 你可以这么理解，基于 Mysql 5.6 / Mysql 5.7 改造的
我问：那我不用改配置也能使用Aurora了？
高工答：分布式共享存储，更短的恢复时间， 我们amazon 内部 把oracle 几乎全部替换为Aurora。Aurora 是商业级的数据库，配置都不用改的，完全兼容，除了一点 你们如果用 MYISAM 引擎 需要改成 innodb
我问：那我可以理解用了Aurora都不用只读副本吗？
高工答：不是的，他依然要只读副本；只是相同配置实例，Aurora 性能高于Mysql。
我问：那我理解只读副本是用来抗高并发的，对吗？
高工答：是的，就是把读部分的负载 分离出来到其它机器， 主库只做 写
我问：只读副本创建也是类似于上午创建那个写库一样的吗？
高工答：只读副本，在主库里面 点击创建即可；
Amazon RDS 上的 MySQL
Amazon RDS 支持运行若干版本 MySQL 的数据库实例
- MySQL 8.0
- MySQL 5.7
- MySQL 5.6
- MySQL 5.5
Amazon RDS 主要组件
数据库实例、区域、可用区、安全组、参数组和选项组
创建运行 MySQL 数据库引擎的数据库实例
Amazon RDS 的基本构建基块是数据库实例。数据库实例是指创建 MySQL 数据库的位置。
-
主要点
必须先完成设置 Amazon RDS部分中的任务，然后才能创建或连接到数据库实例。
- 设置 Amazon RDS
创建 MySQL 数据库实例并连接到 MySQL 数据库实例上的数据库
创建数据库实例的最轻松方法是使用 AWS 管理控制台。在创建数据库实例之后，可使用标准 MySQL 实用程序 (例如，MySQL Workbench) 连接到数据库实例上的数据库。
- 创建 MySQL 数据库实例
- 与运行 MySQL 数据库引擎的数据库实例上的数据库连接
- 删除数据库实例
创建 MySQL 数据库实例
Amazon RDS 的基本构建基块是数据库实例。这是运行 MySQL 数据库的环境。
示例中创建一个数据库实例:
创建 MySQL 数据库实例
- 登录 AWS 管理控制台 并通过以下网址打开 Amazon RDS 控制台：https://console.aws.amazon.com/rds/。
- 在 Amazon RDS 控制台的右上角，选择要在其中创建数据库实例的 AWS 区域。
选择查看数据库实例详细信息。
在 RDS 控制台上，将显示新数据库实例的详细信息。数据库实例具有 creating 状态，直到该数据库实例可供使用。当状态变为 Available 时，您可以连接到该数据库实例。根据数据库实例类和存储量，新实例可能需要等待 20 分钟时间才可用。
与运行 MySQL 数据库引擎的数据库实例上的数据库连接
在 Amazon RDS 预配置了数据库实例后，即可使用任何标准 SQL 客户端应用程序与该数据库实例上的数据库连接。
示例中，使用 MySQL 监视器命令连接到 MySQL 数据库实例上的数据库。在基于 GUI 的应用程序中，可以使用 MySQL Workbench 进行连接；
使用 MySQL 监视器与数据库实例上的数据库连接
- 找到数据库实例的终端节点 (DNS 名称) 和端口号。
a. 打开 RDS 控制台，然后选择 Databases (数据库) 以显示数据库实例的列表;
b. 选择 MySQL 数据库实例名称以显示其详细信息。
c.在 Connectivity (连接) 选项卡上，复制终端节点。另请注意端口号。您需要终端节点和端口号才能连接到数据库实例。
- 连接到 MySQL 数据库实例的数据库,例如，使用 MySQL 客户端在客户端计算机上的命令提示符下输入以下命令，以便连接至 MySQL 数据库实例的数据库。替换 的数据库实例的 DNS 名称，替换用于 的主用户名，并在系统提示输入密码时提供所用的主密码。
如果无法连接到 MySQL 数据库实例，那么导致新数据库实例连接故障的两个常见原因是：
- 创建数据库实例时所用的安全组无法授权连接运行 MySQL 应用程序或实用程序的设备或 Amazon EC2 实例。如果数据库实例是在 VPC 内部创建的，则该 VPC 必须包含可授权连接的 VPC 安全组。如果数据库实例是在 VPC 外部创建的，则该 VPC 必须包含可授权连接的数据库安全组
- 数据库实例是使用默认端口 3306 创建的，而您公司的防火墙规则不允许公司网络中的设备连接到该端口。要修复此故障，请重新创建使用不同端口的实例。
删除数据库实例
在连接到创建的示例数据库实例之后，您应当删除数据库实例，因此无需为其付费。
删除无最终数据库快照的数据库实例
-
登录 AWS 管理控制台 并通过以下网址打开 Amazon RDS 控制台：https://console.aws.amazon.com/rds/。
-
在导航窗格中，选择 Databases (数据库)。
如果导航窗格已关闭，请选择左上角的菜单图标以将其打开。
-
选择要删除的数据库实例。
-
对于 Actions (操作)，选择 Delete (删除)。
-
对于 Create final snapshot? (是否创建最终快照?)，选择 No (否)，然后确认选择。
-
选择 Delete。
单例连接
package com.tcl.amazondemo.controller;
import com.tcl.amazondemo.pojo.PersonEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.servlet.http.HttpServletRequest;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
@RestController
@RequestMapping(value = "/test")
public class AmazonTestController {
@Autowired
private JdbcTemplate jdbcTemplate;
@RequestMapping(value = "send", method = RequestMethod.POST)
public List<Map<String, Object>> bindingDevice(HttpServletRequest request){
String sql = "select * from amazonuser";
List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
for (Map<String, Object> map : list) {
Set<Map.Entry<String, Object>> entries = map.entrySet( );
if(entries != null) {
Iterator<Map.Entry<String, Object>> iterator = entries.iterator( );
while(iterator.hasNext( )) {
Map.Entry<String, Object> entry =(Map.Entry<String, Object>) iterator.next( );
Object key = entry.getKey( );
Object value = entry.getValue();
System.out.println(key+":"+value);
}
}
}
return list;
}
}
配置
server:
port: 8889
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://mysql-instance1.cjhlzjielcdr.us-west-2.rds.amazonaws.com:3306/iot_test1?characterEncoding=utf8&useSSL=false
username: ****
password: ****
max-idle: 10
max-wait: 10000
min-idle: 5
max-active: 10
initial-size: 5
validation-query: SELECT 1
test-on-borrow: false
test-while-idle: true
time-between-eviction-runs-millis: 18800
高可用性功能不是面向只读情况的扩展解决方案；不能使用备用副本处理读取流量。要处理只读流量，应当使用只读副本；
创建只读副本时需要本地访问需要在创建时添加
主库和只读副本配置如下：
server:
port: 8889
spring:
datasource:
master:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://mysql-instance1.cjhlzjielcdr.us-west-2.rds.amazonaws.com:3306/iot_test1?characterEncoding=utf8&useSSL=false
username: ****
password: ****
max-idle: 10
max-wait: 10000
min-idle: 5
max-active: 10
initial-size: 5
validation-query: SELECT 1
test-on-borrow: false
test-while-idle: true
time-between-eviction-runs-millis: 18800
slave:
url: jdbc:mysql://dump-datasource.cjhlzjielcdr.us-west-2.rds.amazonaws.com/iot_test1?characterEncoding=utf8&useSSL=false
username: ****
password: ****
RDS For Aurora
创建Aurora数据库时，它会默认的创建上只读副本
一个是主库 支持读写，一个副本只支持读
创建跨区域只读副本 把一个副本创建到 其它region。比如主库在印度 从库可以到美国 日本，比如需要多区域部署 ，想把各个区域数据聚合到同一个region
结论：RDS For mysql 与RDS For Aurora 对比，从高工提供的数据性能在mysql版本是5.6，5.7上对比 Aurora性能是Mysql的几倍以上，Aurora在创建的主库的时候会自动的添加它的只读副本,Mysql需要我们自己去添加，备用实例上Aurora是可见的即支持可读Mysql不支持，使用上配置文件只需改变他们的endpoint即可使用，但是Aurora使用引擎需要选择InnoDB;另外Aurora支持跨区域只读副本（主库和从库可以在不同region）