Elastic
pools help you improve operating efficiency and reduce costs by bringing all of your
databases to the Cloud. This also supports consolidating resources and simplifying
administration and operations by using Autonomous Database.
Elastic pools are only available for Autonomous Database instances that use the ECPU compute model.
When you need a large number of databases that can scale up and down
elastically without downtime, you can benefit by creating and using elastic pools.
Elastic pools have the following advantages:
Enable operating with a fixed budget for a group of databases, while
delivering performance elasticity for each individual database.
Allow for easy migration from on-prem Oracle environments that
include oversubscription, to provide a cost effective way to move to Autonomous Database.
Support SaaS vendors with a large number of individual customer
databases.
Provide resources for using a microservices architecture, where the
ability to supply of large number of databases is required.
The pool members in an elastic pool are not billed individually (the
pool leader is billed based on the pool shape). You can allocate additional
ECPUs per instance for pool members, without worrying about the cost associated
with the ECPU usage for the individual members. Autonomous Database IO capacity and
memory allocation is directly correlated with the ECPU
count, so by selecting a greater number of ECPUs for an
instance, this allows you to run with greater IO capacity and more memory
without having to pay for the additional resources. This means, using a larger
number of ECPUs per instance allows you to use more IO capacity and more memory
per instance, where the cost is based on the pool shape and is not based on an
individual instance's ECPU count.
When you create an elastic pool you select a pool size from a predefined set
of pool sizes. Pool size determines how much you pay for compute as well as how many
ECPUs you can provision in a given pool.
There are several terms to use when you work with elastic pools:
Pool Leader: Is the Autonomous Database instance that creates an elastic pool.
Pool Member: Is an Autonomous Database instance that is added to an elastic pool.
Pool Size: Is a value that you set when you create an elastic
pool. The pool size must be one of the available elastic pool shapes.
Pool Shape: A pool shape is one of the valid pool sizes that
you select when you create an elastic pool. The pool shape must be one of: 128, 256, 512, 1024, 2048, or
4096 ECPUs.
Note
By default each instance in an
elastic pool is automatically assigned a maintenance window. By selecting a pool
shape that is 1024 ECPUs or greater, you have the option of assigning a custom
2-hour maintenance window during which the leader and all elastic pool members
are patched together. To select a custom maintenance window for your elastic
pool, file a Service Request at Oracle Cloud
Support.
Pool Capacity: The pool capacity is the maximum number of
ECPUs that an elastic pool can use, and is four times (x4) the pool size.
Requirements to Create an Elastic
Pool
The following are the requirements for an Autonomous Database instance to create an
elastic pool and become a pool leader:
The instance must use the ECPU compute model.
The instance must be an Autonomous Database instance with the Transaction
Processing workload type. This only applies for the pool
leader. An elastic pool can hold a mix of databases with
Transaction Processing, Data
Warehouse, JSON Database, or
APEX workloads.
Auto scaling must be disabled.
The instance must not be a member of an existing elastic
pool.
The maximum allowed individual ECPU count
for an Autonomous Database
instance that creates an elastic pool is 4 times the pool size specified
when you create the pool.
The instance that creates an elastic pool is subject to tenancy
limits. To create an elastic pool you must have a sufficient number of ECPUs
available, below the tenancy limit, to accommodate the size of the elastic
pool.
Requirements to Join an Elastic
Pool
The following are the requirements for an Autonomous Database instance to join an
elastic pool:
The instance must use the ECPU compute model.
An elastic pool can contain Autonomous Database instances with Transaction
Processing, Data Warehouse,
JSON Database, or APEX
workload types.
An elastic pool can hold a mix of databases with
Transaction Processing, Data
Warehouse, JSON Database, and
APEX workloads.
Auto scaling must be disabled.
The instance must not be a member of an elastic pool.
The maximum allowed individual ECPU count
for an Autonomous Database
instance is the available pool capacity. When an instance has an ECPU count
greater than the available pool capacity, it is not allowed to join that
elastic pool.
Pool Leader and Member Instance
ECPU Allocation
When an Autonomous Database
instance is part of an elastic pool, the minimum allowed individual ECPU allocation
for an instance is 1 ECPU.
When an Autonomous Database
instance is part of an elastic pool, increments of 1 ECPU are allowed for individual
Autonomous Database instance ECPU
allocation.
Pool Capacity for an Elastic
Pool
An elastic pool has a pool capacity of 4 times the pool size. For
example, a pool with pool size of 128 ECPUs can hold up to 512 ECPUs for its leader
and the members.
The following are examples of Autonomous Database instances that could be in an elastic pool with a pool
size of 128 and a pool capacity of 512:
Each of these are valid for pool members in an elastic pool with a
pool size of 128:
1 instance with 512 ECPUs, for a total of 512 ECPUs
128 instances with 4 ECPUs, for a total of 512 ECPUs
256 instances with 2 ECPUs, for a total of 512 ECPUs
50 instances with 10 ECPUs and 3 instances with 4 ECPUs,
for a total of 512 ECPUs
Similarly, each of the following are valid for pool members in an
elastic pool with a pool size of 128:
1 instance with 128 ECPUs, 2 instances with 64 ECPUs, 32
instances with 4 ECPUs, and 64 instances with 2 ECPUs, for a total
of 512 ECPUs
256 instances with 1 ECPU, 64 instances with 2 ECPUs,
for a total of 384 ECPUs, which is less than the pool capacity of
512 ECPUs.
100 instances with 4 ECPUs and 50 instances with 2
ECPUs, which is less than the pool capacity of 512 ECPUs.
These are examples, you can add pool members to a pool to match the number of
instances and the number ECPUs per instance to meet your needs, based on the pool
size you select.
Topics
About Elastic Pool Billing Elastic pool usage is billed to the pool leader and billing is based on the elastic pool size and the actual hourly ECPU usage of the pool leader and the members. Elastic pool usage can exceed the pool size (pool capacity can be up to four times greater than the pool size).
About Elastic Pool Leader and Member Operations The Autonomous Database instance that creates an elastic pool is the pool leader. Autonomous Database instances that are added to an existing pool are pool members. Depending on your role, either leader or member, you can perform operations on an elastic pool.
Elastic pool usage is billed to the pool leader and billing is based
on the elastic pool size and the actual hourly ECPU usage of the pool leader and the
members. Elastic pool usage can exceed the pool size (pool capacity can be up to four
times greater than the pool size).
The billing for an elastic pool consists of only compute resources, that is
ECPU usage, and all compute usage is charged to the Autonomous Database instance that is the pool leader. Any billing for storage
usage is charged separately to individual Autonomous Database instances, independent of whether the instance is in an
elastic pool.
An elastic pool allows you to consolidate your Autonomous Database instances in terms of
their compute resource billing. You can think of an elastic pool like a mobile phone
service “family plan”, except this applies to your Autonomous Database instances. Instead of paying individually for each
database, the databases are grouped into a pool in which one instance, the leader, is
charged for the compute usage associated with the entire pool.
Using an elastic pool you are able to provision up to four times the number
of ECPUs, over your selected pool size, and you can provision database instances that
are in the elastic pool with as little as 1 ECPU per database instance. Outside of an
elastic pool the minimum number of ECPUs per database instance is 2 ECPUs. For example,
with a pool size of 128 you can provision 512 Autonomous Database instances (when each instance has 1 ECPU). In this example
you are billed for the pool size compute resources, based on the pool size of 128 ECPUs,
while you have access to 512 Autonomous Database instances. In contrast, when you individually provision 512 Autonomous Database instances without using an
elastic pool you are required to allocate a minimum of 2 ECPUs for each Autonomous Database instance, and in this
example you would pay for 1024 ECPUs. Using an elastic pool provides up to 87%
compute cost savings.
After you create an elastic pool, the total ECPU usage for a given hour is
charged to the Autonomous Database instance
that is the pool leader. With the exception of the pool leader, individual Autonomous Database instances that are pool
members are not charged for ECPU usage while they are members of an elastic pool.
Elastic pool billing is as follows:
If the total aggregated peak ECPU utilization is equal to or below
the pool size for a given hour, you are charged for the pool size number of
ECPUs (one times the pool size).
After an elastic pool is created ECPU billing continues at a minimum
of one times the pool size rate, even when databases that are part of the pool
are stopped. This applies to pool member databases and to the pool leader.
In other words, if the aggregated peak ECPU utilization of the pool
is less than or equal to the pool size for a given hour, you are charged for the
pool size number of ECPUs (one times the pool size). This represents up to
87% compute cost savings over the case in which these databases are
billed separately without using elastic pools.
If the aggregated peak ECPU utilization of the pool leader and the
members exceeds the pool size at any point in time in a given billing hour:
Aggregated peak ECPU utilization of the pool is equal to
or less than two times of the pool size number of ECPUs: For
usage that is greater than one times the pool size number of ECPUs and
up to and including two times the number of ECPUs in a given billing
hour: Hourly billing is two times the pool size number of ECPUs.
In other words, if the aggregated peak ECPU utilization of
the pool exceeds the pool size, but is less than or equal to two times
the pool size for a given hour, you are charged for twice the pool size
number of ECPUs (two times the pool size). This represents up to 75%
compute cost savings over the case in which these databases are
billed separately without using elastic pools.
Aggregated peak ECPU utilization of the pool is equal to
or less than four times the pool size number of ECPUs: For usage
that is greater than two times the pool size number of ECPUs and up and
including to four times the pool size number of ECPUs in a given billing
hour: Hourly billing is four times the pool size number of ECPUs.
In other words, if the aggregated peak ECPU utilization of
the pool exceeds twice the pool size for a given hour, you are charged
for four times the pool size number of ECPUs (four times the pool size).
This represents up to 50% compute cost savings over the case in
which these databases are billed separately without using elastic
pools.
For example, consider an elastic pool with a pool size of 128 ECPUs
and a pool capacity of 512 ECPUs:
Case-1: The aggregated peak ECPU utilization of the
pool leader and the members is 40 ECPUs between 2:00pm and 2:30pm, and
128 ECPUs between 2:30pm and 3:00pm.
The elastic pool is billed 128 ECPUs, one times the pool
size, for this billing hour (2-3pm). This case applies when the peak
aggregated ECPU usage of the elastic pool for the billing hour is less
than or equal to 128 ECPUs.
Case-2: The aggregated peak ECPU utilization of the
pool leader and the members is 40 ECPUs between 2:00pm and 2:30pm, and
250 ECPUs between 2:30pm and 3:00pm.
The elastic pool is billed 256 ECPUs, two times the pool
size, for this billing hour (2-3pm). This case applies when the peak
aggregated ECPU usage of the elastic pool for the billing hour is less
than or equal to 256 ECPUs and greater than 128 ECPUs.
Case-3: The aggregated peak ECPU utilization of the
pool leader and the members is 80 ECPUs between 2:00pm and 2:30pm, and
509 ECPUs between 2:30pm and 3:00pm.
The elastic pool is billed 512 ECPUs, four times the pool
size, for this billing hour (2-3pm). This case applies when the peak
aggregated ECPU usage of the elastic pool for the billing hour is less
than or equal to 512 ECPUs and greater than 256 ECPUs.
Elastic Pool Billing when a Pool
is Created or Terminated
When an elastic pool is created or terminated, the leader is billed for
the full hour for the elastic pool. In addition, individual instances that are
either added or removed from the pool are billed for any compute usage that occurs
while the instance is not in the elastic pool (in this case the billing applies to
the individual Autonomous Database
instance).
Pool Creation Example: Assume there is an Autonomous Database instance with
4 ECPUs that is not part of any elastic pool. At 2:15pm, if you create an
elastic pool with this instance with a pool size of 128 ECPUs, the instance
becomes a pool leader. Assuming the Autonomous Database idles between 2-3pm, and there are no other
Autonomous Database instances
in the pool, billing for the hour between 2-3pm is as follows:
The bill for the period 2-3pm is: (4 * 0.25) + 128 = 129
ECPUs
Where the (4 * 0.25) is the billing for compute for the fifteen
minutes before the Autonomous Database instance created the elastic pool, and 128 ECPUs is the
billing for the elastic pool for the hour when the elastic pool is
created.
Pool Termination Example: Assume an Autonomous Database instance with
4 ECPUs is the leader of an elastic pool and the pool size is 128 ECPUs. At
4:30pm, if you terminate the elastic pool, the database becomes a standalone
Autonomous Database instance
that is not part of any elastic pool. Assuming the Autonomous Database idles between
4-5pm, and there are no other Autonomous Database instances in the pool, billing for the hour
between 4-5pm is as follows:
The bill for 4-5pm is: (4 * 0.5) + 128 = 130 ECPUs
Where the (4 * 0.5) is the billing for compute for the thirty
minutes after the Autonomous Database instance terminates the elastic pool, and 128 ECPUs is the
billing for the elastic pool for the hour when the elastic pool was
terminated.
Elastic Pool Billing with Built-in
Tools
For either the pool leader or the members, compute resources that are
allocated to the built-in tools, OML, Graph, or Data Transforms, are separate and do
not count towards the elastic pool total allocation. For billing purposes, the
elastic pool leader is billed for any built-in tool ECPU usage by either the leader
or elastic pool members, in addition to the elastic pool ECPU usage.
For example, assume there is an elastic pool with a pool size of 128
ECPUs; if in a given billing hour the aggregated peak ECPU utilization of the pool
leader and the members is 80 ECPUs for the billing hour, and during this hour the
combined total ECPU utilization for instances using built-in tools is 30 ECPUs, the
leader is charged for the pool size (128 ECPUs), plus the built-in tool ECPU usage
(30 ECPUs), for a total of 158 ECPUs for that hour.
Elastic Pool Usage Details in OCI
Usage Reports and OCI_USAGE_DATA View
You can obtain a detailed breakdown of elastic pool usage in the Oracle Cloud
Infrastructure (OCI) usage reports and this information is also shown in the
OCI_USAGE_DATA view. See Cost and Usage Reports and
OCI_USAGE_DATA View for more information.
The following table shows the product/resource column
values in an OCI usage report. The OCI usage report provides details on elastic pool
usage for the pool leader and for pool members a given billing hour (similar
information is available in OCI_USAGE_DATA view):
Elastic Pool Usage Type
Billing Hour Values Shown
Member Compute Usage
For a given pool member where the
product/resourceId column of the OCI usage
report is equal to pool member’s OCID and the
product/resource column of the OCI usage
report is equal to PIC_ADBS_DB_ECPU_PEAK, the
usage/billedQuantity of the OCI usage
report shows the peak ECPU usage of the member in a specified
billing hour.
You can use the following query to view the same
usage details in the OCI_USAGE_DATA view:
SELECT billed_quantity FROM OCI_USAGE_DATA
WHERE resource_name='PIC_ADBS_DB_ECPU_PEAK' and
resource_id=OCID_of_the_pool_member and
interval_usage_start=start_time and
interval_usage_end=end_time
Note
If a member has
a local a local Autonomous Data
Guard standby, its peak usage will be
reported as two times (2 x) the peak
usage.
Leader Compute Usage
For a given pool leader where the
product/resourceId column of the OCI usage
report is equal to pool leader's OCID and the
product/resource column of the OCI usage
report is equal to PIC_ADBS_DB_ECPU_PEAK, the
usage/billedQuantity of the OCI usage
report shows the peak ECPU usage of the leader in a specified
billing hour.
You can use the following query to view the same
usage details in the OCI_USAGE_DATA view:
SELECT billed_quantity FROM OCI_USAGE_DATA
WHERE resource_name='PIC_ADBS_DB_ECPU_PEAK' and
resource_id=OCID_of_the_pool_leader and
interval_usage_start=start_time and
interval_usage_end=end_time
Note
If the leader
has a local a local Autonomous Data
Guard standby, its peak usage will be
reported as two times (2 x) the peak
usage.
Aggregated Pool Compute Usage
For a given pool leader where the
product/resourceId column of the OCI usage
report is equal to pool leader's OCID and the
product/resource column of the OCI usage
report is equal to
PIC_ADBS_ELASTIC_POOL_DB_ECPU, the
usage/billedQuantity of the OCI usage
report shows the aggregated peak ECPU usage of the leader and
all members in the specified billing hour.
You can use the following query to view the same
usage details in the OCI_USAGE_DATA view:
SELECT billed_quantity FROM OCI_USAGE_DATA
WHERE resource_name='PIC_ADBS_ELASTIC_POOL_DB_ECPU' and
resource_id=OCID_of_the_pool_leader and
interval_usage_start=start_time and
interval_usage_end=end_time
Notes for elastic pool billing information in the OCI usage report and
the OCI_USAGE_DATA view:
Elastic pool aggregate peak ECPU usage is shown for terminated
databases.
Elastic pool aggregate peak ECPU usage is shown for non-pool
databases that were part of an elastic pool during a billing hour when the
database was a member of an elastic pool.
About Elastic Pools with Autonomous Data
Guard Enabled
🔗
The elastic pool leader or members can enable either local or cross-region Autonomous Data
Guard, or both local and
cross-region Autonomous Data
Guard.
Local Autonomous Data
Guard Standby
Database Billing
When you add a local standby, a total of two times (2 x)
the primary's ECPU allocation is counted towards the pool capacity (1
x for the primary and 1 x for the standby).
Meaning a local standby multiplies the primary's peak usage by 2.
For example, if you create an elastic pool with a pool size of 128
ECPUs, with a pool capacity of 512 ECPUs, adding the following Autonomous Database instance uses the
elastic pool capacity:
1 instance with 256 ECPUs with local Autonomous Data
Guard
enabled, for a total of 512 ECPUs allocation from the pool.
When using this instance the CPU utilization is 256 ECPUs,
however the overall peak ECPU utilization will be reported as 512 because of
the local standby database 2 x multiplication factor. And
the billing is based on 4 x the pool size (512 ECPUs).
Similarly, if you create an elastic pool with a pool size of 128 ECPUs,
with a pool capacity of 512 ECPUs, adding the following Autonomous Database instances uses the
elastic pool capacity as follows:
128 instances with 2 ECPUs each, with local Autonomous Data
Guard
enabled, for a total of 512 ECPUs allocation from the pool.
When all of these databases are running, peak 100% ECPU
utilization, you get 256 ECPUs as your peak (128 *2 ECPUs per instance).
However, the overall peak ECPU utilization of the pool will be reported
as 512 because of the 2 x factor for the standby
databases. Billing in this case is based on 4 x the
pool size, or 512 ECPUs.
Cross-Region Autonomous Data
Guard Standby
Database Billing
Enabling Cross-region Autonomous Data
Guard for a leader or for member has no effect on the
elastic pool capacity. A cross-region Autonomous Data
Guard peer database has its own OCID and the cross-region
peer is billed independently from the elastic pool.
Note the following:
Cross-region Autonomous Data
Guard peer ECPUs do not use pool capacity and billing for Autonomous Data
Guard
cross-region peer databases happens on the peer instance.
When the leader of an elastic pool enables cross-region Autonomous Data
Guard, the
cross-region peer database ECPU allocation does not count towards the
elastic pool capacity. Billing for cross-region Autonomous Data
Guard is on
the cross-region instance, which is not part of the elastic pool (elastic
pools do not operate across regions).
When a member of an elastic pool enables cross-region Autonomous Data
Guard, the
cross-region peer ECPU allocation does not count towards the pool capacity.
Billing for cross-region Autonomous Data
Guard is on the cross-region instance, which is
not part of the elastic pool (elastic pools do not operate across
regions).
For example, if you create an elastic pool with a pool size of 128 ECPUs
(with a pool capacity of 512 ECPUs), adding the following Autonomous Database instances of different
sizes uses the entire elastic pool capacity:
A pool that contains the following instances:
1 instance with 128 ECPUs with cross-region Autonomous Data
Guard enabled (using a total of 128 ECPUs from the
pool).
64 instances with 2 ECPUs each with both local and cross-region
Autonomous Data
Guard enabled (using a total of 256 ECPUs from the
pool).
128 instances with 1 ECPU, each with cross-region Autonomous Data
Guard enabled (using 128 ECPUs from the pool).
The Autonomous Database instance that creates an elastic
pool is the pool leader. Autonomous Database instances
that are added to an existing pool are pool members. Depending on your role, either leader or
member, you can perform operations on an elastic pool.
Pool Leader Operations
The following operations are valid only for the pool leader:
Operation
Description
Create an elastic pool
The Autonomous Database instance that creates
an elastic pool is the pool leader. See Create an Elastic Pool for more information.
The following operations are valid for a pool member or for the pool
leader:
Operation
Description
Add instance to elastic pool
An Autonomous Database instance can be added
as a pool member as long as the instance is one of the supported workload types,
the instance uses the ECPU compute model, and the instance is not a pool member of
a different pool. The supported workload types are: Transaction
Processing, Data Warehouse, JSON
Database, or APEX.