Introduction

Oracle Exascale Database Service introduces a different way of deploying and managing Oracle databases compared with the traditional Exadata architecture.

In a traditional Exadata environment, DBAs commonly think in terms of:

Database
   ↓
ASM
   ↓
Grid Disks
   ↓
Cell Disks
   ↓
Exadata Storage Cells

With Oracle Exascale, the storage architecture is abstracted differently.

The OCI-managed Exascale architecture provides:

Exascale Storage Vault
Exascale VM Clusters
Exascale Smart Storage
Oracle Grid Infrastructure
Oracle Database
CDB/PDB architecture
OCI networking
IAM and security
Integrated backup and recovery capabilities

In this hands-on exercise, I walked through the complete process of creating an Exascale environment and then creating an Oracle Database and PDB.

1. High-Level Oracle Exascale Architecture

A simplified architecture looks like this:

                         OCI TENANCY
                              |
                    +---------+---------+
                    |                   |
                  IAM              COMPARTMENT
                    |                   |
                    +---------+---------+
                              |
                             VCN
                              |
                    +---------+---------+
                    |                   |
              Client Subnet        Other Subnets
                    |
                    |
             Exascale VM Cluster
                    |
          +---------+---------+
          |                   |
     Grid Infrastructure   Oracle Database
          |                   |
     CRS / SCAN / VIP        CDB
                              |
                    +---------+---------+
                    |                   |
                   PDBs              PDB$SEED
                             
                    |
                    ↓
          Exascale Smart Storage
                    |
                    ↓
          Exascale Storage Vault

The important architectural concept is:

Compute and storage are separated logically in Exascale.

The database compute environment runs inside the Exascale VM Cluster, while database storage is provided through Exascale Storage.

2. Main Components

Before creating an Exascale environment, it is important to understand the major components.

OCI Compartment

The compartment provides logical organization and isolation for OCI resources.

For example:

Prod_Db_Comp

Resources such as:

VM Cluster
Storage Vault
Networking resources
Databases

can be organized within appropriate compartments.

3. OCI IAM

IAM controls who can create, modify, access, and administer the resources.

Typical IAM components include:

User
  ↓
Group
  ↓
Policy
  ↓
OCI Resource

For an Exascale environment, IAM should be designed before provisioning.

4. VCN and Networking

The Exascale VM Cluster requires OCI networking.

The basic architecture is:

VCN
 |
 +-- Client Subnet
 |
 +-- Other required subnets
 |
 +-- Route Tables
 |
 +-- Security Lists / NSGs

The client subnet is particularly important because it provides connectivity to the database environment.

Before creating the VM Cluster, verify:

VCN exists
Client subnet exists
DNS configuration is correct
Route table is correct
Security rules are configured
Required ports are allowed
SSH access is available through the approved network path

5. Security Rules

For a pre-production or production environment, SSH should not normally be opened to the entire internet.

Instead, access can be controlled through:

Corporate network
VPN
FastConnect
Bastion
Approved private CIDR
NSG/security list rules

For example:

Corporate Network
       |
       ↓
     VPN
       |
       ↓
OCI VCN
       |
       ↓
Client Subnet
       |
       ↓
Exascale VM

This provides a much safer architecture than simply allowing:

0.0.0.0/0 → TCP 22

6. Create the Exascale Storage Vault

The next major component is the Exascale Storage Vault.

From OCI Console:

Oracle AI Database → Exadata Database Service on Exascale Infrastructure → Storage Vaults

Select:

Create Storage Vault

Provide the required details such as:

Name
Compartment
Availability Domain
Storage configuration

For example:

Storage Vault:
exascale-prod-vault

The Storage Vault becomes the storage foundation for the Exascale environment.

7. What Does the Storage Vault Provide?

Conceptually:

Exascale Storage Vault
        |
        +-- Database Data
        |
        +-- Datafiles
        |
        +-- Tempfiles
        |
        +-- Recovery-related storage
        |
        +-- High-performance storage

The important point is that DBAs don't have to manually build the traditional CellDisk/GridDisk/ASM layout used in conventional Exadata storage administration.

Exascale provides a different storage-management abstraction.

8. Exascale Smart Storage

One of the important choices when creating the environment is the storage type.

For modern Oracle Database releases, Exascale Smart Storage provides the newer Exascale storage architecture.

However, database version matters.

For example, during the hands-on exercise we discussed the difference between:

Exascale Smart Storage

and:

Exascale Block Storage

The supported storage architecture depends on the Oracle Database version.

This is especially important when working with Oracle Database 19c versus newer Oracle Database releases.

Therefore:

Always check the database version and supported Exascale storage type before creating the VM Cluster.

9. Create the Exascale VM Cluster

After creating the Storage Vault, the next step is to create the Exascale VM Cluster.

Navigate to:

Oracle AI Database → Exadata Database Service on Exascale Infrastructure → VM Clusters

Click:

Create VM Cluster

This is effectively the compute environment for the databases.

10. Configure the VM Cluster

During VM Cluster creation, configure the required parameters.

Typical configuration includes:

Basic information

Name:
exascale-vmcl-prod

Compartment

Select the appropriate compartment.

Availability Domain

Select the required Availability Domain.

VCN

Select the VCN.

Client Subnet

Select the subnet that provides database client connectivity.

Exascale Storage Vault

Select the Storage Vault created earlier.

For example:

exascale-prod-vault

Database Software Version

Select the required Oracle Database version.

In the hands-on environment, the newer Oracle Database release was used.

ECPU

Configure the required ECPU capacity.

Memory

Configure the required memory.

SSH Public Key

Provide the SSH public key required for administration.

11. Review and Create

Before clicking Create, verify:

✓ Compartment
✓ Availability Domain
✓ VCN
✓ Client Subnet
✓ Storage Vault
✓ Database version
✓ ECPU
✓ Memory
✓ SSH key
✓ Network/security configuration

Then:

Review → Create

OCI starts provisioning the Exascale VM Cluster.

12. VM Cluster Provisioning

During provisioning, OCI creates the required compute and infrastructure components.

Conceptually:

OCI
 |
 +-- VM Cluster
       |
       +-- Compute VM(s)
       |
       +-- Grid Infrastructure
       |
       +-- Network resources
       |
       +-- Database services
       |
       +-- Exascale Storage connectivity

Once the VM Cluster becomes:

AVAILABLE

the environment is ready for the next stage.

13. Connect to the Exascale VM

After the VM Cluster is provisioned, connect using the configured SSH key.

Example:

ssh -i <private-key> opc@<private-ip>

Depending on the environment, connectivity may be through:

VPN
FastConnect
Bastion
Private network

Once connected:

sudo su - oracle

Now we can begin inspecting the Oracle environment.

14. Check the Oracle Environment

Typical checks include:

echo $ORACLE_HOME
echo $ORACLE_SID

For example:

ORACLE_HOME=/u02/app/oracle/product/23.0.0.0/dbhome_1
ORACLE_SID=prod01

The Oracle environment provides the database software required to run the database.

15. Understanding Grid Infrastructure

The Exascale environment still uses Oracle Grid Infrastructure for important infrastructure services.

For example:

Grid Infrastructure
       |
       +-- CRS
       +-- SCAN
       +-- VIP
       +-- Database resources
       +-- PDB services

You can inspect cluster resources using:

crsctl stat res -t

This helps identify:

Database resources
SCAN listeners
VIPs
PDB resources
Other GI-managed resources

16. Important Difference: ASM

This was one of the most interesting parts of the Exascale architecture.

In a traditional Exadata environment, DBAs frequently work with:

ASM
 ↓
Grid Disks
 ↓
Cell Servers

But with Exascale Smart Storage, the database storage architecture is different.

In the environment used for the hands-on exercise, there was no ASM PMON for the database storage path.

Therefore, commands such as:

asmcmd

should not automatically be assumed to be the primary storage-management interface.

This is an important architectural difference for DBAs moving from traditional Exadata to Exascale.

17. Create the Oracle Database

Once the VM Cluster is available, create the database.

From OCI Console:

Exadata Database Service on Exascale Infrastructure → Databases → Create Database

Select the VM Cluster.

Then provide:

Database Name:
ProdDB

Database Unique Name:
PROD01

Select the required:

Database version
Database home
Administrator credentials
CDB option
PDB configuration

18. Create the Container Database

The modern Oracle architecture is based on Multitenant.

The architecture becomes:

             PROD01
                |
        Container Database
                |
       +--------+--------+
       |                 |
   PDB$SEED          APPDB1

The CDB provides the container framework for the PDBs.

19. Create the Initial PDB

During database creation, an initial PDB can be created.

For example:

PDB Name:
APPDB1

The PDB can then be opened and used for application workloads.

20. Verify the CDB and PDBs

Connect to the database:

sqlplus / as sysdba

Then:

SHOW PDBS;

You should see something similar to:

NAME       OPEN_MODE
---------- ----------
PDB$SEED   READ ONLY
APPDB1     READ WRITE

This confirms the multitenant architecture is working.

21. Create an Additional PDB Using SQL

One of the useful exercises was creating another PDB directly from SQL rather than through the OCI Console.

First check the container:

SHOW CON_NAME;

Then create the PDB:

CREATE PLUGGABLE DATABASE APPDB2
ADMIN USER pdbadmin IDENTIFIED BY "YourPassword";

Open it:

ALTER PLUGGABLE DATABASE APPDB2 OPEN;

Save its open state:

ALTER PLUGGABLE DATABASE APPDB2 SAVE STATE;

Then verify:

SELECT name, open_mode
FROM v$pdbs;

Expected architecture:

PROD01
 |
 +-- PDB$SEED
 |
 +-- APPDB1
 |
 +-- APPDB2

22. Final Exascale Architecture

After completing the deployment, the overall architecture can be visualized as:

                         OCI
                          |
              +-----------+-----------+
              |                       |
           IAM                    Compartment
              |                       |
              +-----------+-----------+
                          |
                         VCN
                          |
                   Client Subnet
                          |
                          ↓
                Exascale VM Cluster
                          |
             +------------+------------+
             |                         |
       Grid Infrastructure        Oracle Database
             |                         |
       CRS / SCAN / VIP              PROD01
                                       |
                             +---------+---------+
                             |                   |
                          APPDB1              APPDB2
                             |
                             ↓
                  Exascale Smart Storage
                             |
                             ↓
                   Exascale Storage Vault

23. Where Does the Database Storage Live?

This is an important question for DBAs.

In the Exascale environment, database files use Exascale storage paths rather than the traditional manually managed ASM/Grid Disk model.

The storage architecture can be represented as:

Oracle Database
      |
      ↓
Exascale Storage
      |
      ↓
Exascale Storage Vault

The DBA interacts with the database through Oracle Database and the Exascale management interfaces rather than manually building traditional cell-level storage structures.

24. Exascale Storage Management

Exascale provides management interfaces such as:

XSH
ESCLI

These are useful for understanding the Exascale storage layer.

For example, XSH can expose Exascale datasets, vault information, files and storage-related objects.

One important lesson from the hands-on work was that not every ESCLI command can be executed directly from every ExaDB-XS VM.

For example, ESCLI may report:

ESCLI can only run local commands.
On ExaDB cloud services, use xsh instead of ESCLI.

This is because some ESCLI operations require an ExaCTRL endpoint, while cloud-managed ExaDB environments use the appropriate Exascale management path.

25. XSH

The XSH command available in the environment was:

which xsh

Example:

/usr/bin/xsh

Version:

xsh version

XSH provides commands for interacting with Exascale storage objects.

Examples include:

xsh ls
xsh lsdataset
xsh lsacl
xsh man

The exact command availability can depend on the installed XSH version, so:

xsh man <command>

is a useful way to check the command syntax in the actual environment.

26. Storage Vault and Dataset Concepts

The Exascale Storage Vault can contain datasets and storage resources.

Conceptually:

Storage Vault
      |
      +-- Dataset
      |
      +-- Database-related storage
      |
      +-- Volumes
      |
      +-- Other Exascale objects

One important lesson is not to assume that every object visible through XSH represents the physical location of every database datafile.

The Exascale storage abstraction is more complex than simply:

one volume = one database

Therefore, always correlate Exascale storage information with:

V$DATAFILE
V$TEMPFILE

and the database metadata.

27. Database Datafile Architecture

For example:

SELECT file#, name
FROM v$datafile;

This allows us to see the actual database datafile paths.

In Exascale, these paths can reference Exascale storage namespaces.

The important relationship is:

Oracle Datafile
       ↓
Exascale Storage Namespace
       ↓
Exascale Storage Vault

28. Database Home vs Grid Home

Another useful concept is understanding the Oracle software homes.

The environment contains:

/u01/app/oracle/
       |
       +-- product/
       |      |
       |      +-- 23.0.0.0/
       |             |
       |             +-- dbhome_1
       |
       +-- grid/

The Database Home contains Oracle Database software.

The Grid Infrastructure Home contains GI software.

They have different purposes.

29. Upgrade Considerations

During the hands-on work, we also discussed an important operational rule:

For an operating system/database upgrade workflow, follow the supported upgrade order for the specific Exascale release.

Do not assume that database software should always be upgraded first.

For the workflow discussed in the environment:

Operating System
       ↓
Database / DRID

The exact supported sequence should always be verified against the Oracle documentation for the specific release before performing an actual production upgrade.

30. Networking Troubleshooting During VM Cluster Creation

One practical issue encountered during provisioning was network/security configuration.

The VM Cluster provisioning process requires required connectivity.

If the required SSH/network rule isn't available, provisioning or subsequent administration can fail.

The troubleshooting process was:

Check subnet
      ↓
Check security list / NSG
      ↓
Check TCP 22
      ↓
Check required database ports
      ↓
Check route table
      ↓
Retry provisioning

For pre-production/production, use the appropriate corporate CIDR or private connectivity rather than opening SSH globally.

31. Why Exascale Is Interesting for DBAs

Traditional Exadata administration often requires deep understanding of:

Cell Servers
Physical Disks
Cell Disks
Grid Disks
ASM
Failure Groups
Smart Scan
Flash Cache
IORM

Exascale changes the storage management abstraction.

The DBA can focus more on:

Database
   ↓
Storage Vault
   ↓
Exascale Storage

while OCI/Exascale manages much of the underlying infrastructure.

This doesn't mean the underlying infrastructure becomes irrelevant.

It means the DBA interacts with it differently.

32. Traditional Exadata vs Exascale

Traditional Exadata

DB
 ↓
ASM
 ↓
Grid Disk
 ↓
Cell Disk
 ↓
Physical Disk
 ↓
Cell Server

Exascale

DB
 ↓
Exascale Storage
 ↓
Storage Vault
 ↓
Exascale Infrastructure

This abstraction makes Exascale particularly interesting for cloud database deployments.

33. Post-Creation Checklist

After creating the Exascale environment, I recommend verifying:

✓ VM Cluster is AVAILABLE
✓ Storage Vault is AVAILABLE
✓ Network connectivity works
✓ SSH access works
✓ Grid Infrastructure is healthy
✓ SCAN/listeners are running
✓ Database is OPEN
✓ CDB is READ WRITE
✓ PDBs are OPEN
✓ Database services are available
✓ Datafiles are accessible
✓ Backup configuration is available
✓ Monitoring is working

34. End-to-End Creation Flow

The entire deployment can be summarized as:

OCI Compartment
       ↓
IAM
       ↓
VCN
       ↓
Client Subnet
       ↓
Security / Routing
       ↓
Exascale Storage Vault
       ↓
Exascale VM Cluster
       ↓
SSH Access
       ↓
Grid Infrastructure
       ↓
Database Home
       ↓
Container Database
       ↓
Initial PDB
       ↓
Additional PDBs
       ↓
Backup
       ↓
Monitoring
       ↓
Validation

35. Key DBA Lessons

1. Understand the architecture first

Don't start with commands.

Understand:

OCI
 ↓
VM Cluster
 ↓
GI
 ↓
Database
 ↓
PDB
 ↓
Exascale Storage

2. Storage architecture is different

Don't automatically apply traditional CellCLI/ASM concepts to Exascale Smart Storage.

The architecture is different.

3. Network configuration is part of database provisioning

A database deployment can fail because of:

Security rules
Routing
Subnet configuration
SSH access
Required ports

The DBA therefore needs basic OCI networking knowledge.

4. IAM is part of DBA work in cloud

Database administration in OCI involves more than SQL.

The DBA may need to understand:

IAM
Policies
Groups
Compartments
Dynamic Groups
Object Storage
Networking

5. CDB/PDB knowledge is essential

Modern Oracle Database deployments are heavily based on Multitenant.

Understanding:

CDB
PDB$SEED
PDB
Services
Open Mode
Save State

is essential.

36. Final Takeaway

Building an Exascale environment helped me connect the different layers of modern Oracle database engineering:

                    OCI
                     |
              +------+------+
              |             |
             IAM           VCN
              |             |
              +------+------+
                     |
             Exascale VM Cluster
                     |
             Grid Infrastructure
                     |
                Oracle DB
                     |
              CDB / PDB
                     |
          Exascale Smart Storage
                     |
          Exascale Storage Vault
                     |
              Backup / DR

The biggest takeaway is:

Modern Oracle DBAs need to understand both Oracle Database internals and the cloud infrastructure supporting the database.

Exascale is a good example of this evolution.

It combines:

Oracle Database + Grid Infrastructure + OCI Networking + IAM + Exascale Storage + Cloud Management + Backup & Recovery

into a single database platform.

And this is only the beginning.

The next level is understanding Exascale Storage Vault internals, XSH, ESCLI, datasets, volumes, storage performance, Smart Storage behavior, database I/O, backup/recovery, and performance testing with Storage Index and HCC.

Oracle Exascale Database Service: Architecture and Creating an Exascale VM Cluster — Complete Hands-On Guide

1. High-Level Oracle Exascale Architecture

2. Main Components

OCI Compartment

3. OCI IAM

4. VCN and Networking

5. Security Rules

6. Create the Exascale Storage Vault

7. What Does the Storage Vault Provide?

8. Exascale Smart Storage

9. Create the Exascale VM Cluster

10. Configure the VM Cluster

Basic information

Compartment

Availability Domain

VCN

Client Subnet

Exascale Storage Vault

Database Software Version

ECPU

Memory

SSH Public Key

11. Review and Create

12. VM Cluster Provisioning

13. Connect to the Exascale VM

14. Check the Oracle Environment

15. Understanding Grid Infrastructure

16. Important Difference: ASM

17. Create the Oracle Database

18. Create the Container Database

19. Create the Initial PDB

20. Verify the CDB and PDBs

21. Create an Additional PDB Using SQL

22. Final Exascale Architecture

23. Where Does the Database Storage Live?

24. Exascale Storage Management

25. XSH

26. Storage Vault and Dataset Concepts

27. Database Datafile Architecture

28. Database Home vs Grid Home

29. Upgrade Considerations

30. Networking Troubleshooting During VM Cluster Creation

31. Why Exascale Is Interesting for DBAs

32. Traditional Exadata vs Exascale

Traditional Exadata

Exascale

33. Post-Creation Checklist

34. End-to-End Creation Flow

35. Key DBA Lessons

1. Understand the architecture first

2. Storage architecture is different

3. Network configuration is part of database provisioning

4. IAM is part of DBA work in cloud

5. CDB/PDB knowledge is essential

36. Final Takeaway

Comments

Post a Comment