Shown RDS statistics are too global and broad to provide an answer to the question "Who is to blame for the increased load?".
There are serveral ways to profile your queries, but as you are using RDS with MySQL 5.6, I would recommend you to use PERFORMANCE_SCHEMA
to do it easily, as you won't need external software (some of which is not fully RDS-compatible). Here you have a video with an introduction to query profiling, with examples like IOPS and temporary table creation monitoring by query pattern, user and table. For a more specific guide (specially for configuration of metrics), you can have a look at the official manual and the sys schema documentation.
For a quick check you can also have a look at your SHOW GLOBAL STATUS like 'com\_%';
and SHOW GLOBAL STATUS like 'Hand%';
at time interval to see if you have an increase on the number of SQL queries per unit of time or on the number of engine row operations per unit of time (the first one does not seem abnormal according to the graphs shown).
Your goal is to detect the offending queries first so that you can modify the SQL, your data structure, the MySQL configuration and/or anything peripheral (like if your RDS instance is still good enough) accordingly. An increase on Write IOPS normally may mean extra SQL load (obviously), but also many other things, such as: too many temporary tables or worse query plans being executed due to a change on the query optimiser plan or on your data cardinality/size. It is critical to identify the underlying cause first before taking any action.
AFAIK, you're right that AWS RDS Aurora (a MySQL 5.6 fork) does not support automatic or transparent read/write splitting:
http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Aurora.html
In order to do that in a way that's completely transparent to the application, you would need an intermediate proxy. Your application would then always connect to the proxy, the proxy would then have to do packet inspection to examine each incoming query to determine if it's read-write, which then gets forwarded on to the master, or read-only, which can then get forwarded to any of N replicas.
Be aware that this has some notable implications:
1. This means that the proxy needs to understand the MySQL protocol
2. It needs to inspect each packet (query) and determine if it's RW or RO
3. It then needs to forward the query to the appropriate backend MySQL instance
4. It likely needs to keep track of each connection, maintaining a map of front-end connections between your app and the proxy, and backend connections to the mysqld instances. The front-end connection would remain stable, but the backend connection could change for each query.
5. You can potentially have some state issues as a result. For example, when you start an explicit transaction, create temporary tables, or set session variables in your connection... those could get lost when (transparently) switching backends.
6. This will have an impact on SSL and other security measures, as you are explicitly using a MITM
7. All of this typically adds quite a bit of overhead, and you will typically see noticeable query latency because of it.
This is a feature that we hope to have in the MySQL Router (the replacement for the old MySQL Proxy: http://mysqlhighavailability.com/mysql-router-on-labs-the-newest-member-of-the-mysql-family/), but we do not yet. It takes a lot of time and effort to do it properly, so as to minimize the effects noted above. One such proxy that does support that today is ProxySQL:
http://www.proxysql.com (See the "Read write split" section)
You can grab the source and start playing with it here: https://github.com/renecannao/proxysql
Good luck!
Best Answer
Taking a snapshot is never a bad idea when making changes in a production environment.
That said, it should be safe to delete a replica in RDS as long as you don't have any service connected to it.