Whats new in Autonomous Database in 2022

What’s new in Autonomous Database in
2022
Sandesh Rao
VP AIOps for the Autonomous
@sandeshr
https://www.linkedin.com/in/raosandesh/
https://www.slideshare.net/SandeshRao4
AIOUG – Jul 2022

How to get started with the
Autonomous Database Free Tier

Always Free services enable developers and students to learn, build and get hands-on experience with
Oracle Cloud for unlimited time
Anyone can try for an unlimited time the full functionality of:
• Oracle Autonomous Database
• Oracle Cloud Infrastructure including:
• Compute VMs
• Block and Object Storage
• Load Balancer
Free tier

Free tier – Tech spec
2 Autonomous Databases (Autonomous Data Warehouse or Autonomous Transaction Processing), each
with 1 OCPU and 20 GB storage
2 Compute VMs, each with 1/8 OCPU and 1 GB memory
2 Block Volumes, 100 GB total, with up to 5 free backups
10 GB Object Storage, 10 GB Archive Storage, and 50,000/month API requests
1 Load Balancer, 10 Mbps bandwidth
10 TB/month Outbound Data Transfer
500 million ingestion Datapoints and 1 billion Datapoints for Monitoring Service
1 million Notification delivery options per month and 1000 emails per month

Creating a new Always Free ADB

Creating a new Always Free ADB
Simple toggle to
enable “Always
Free”

Autonomous Database now provides automatic scaling for storage
Copyright © 2021, Oracle and/or its affiliates
Autonomous Database now provides
automatic scaling for storage
Works like auto-scaling for OCPUs
Will automatically expand the base
reserved storage by up to 3x

Defining A Calendar Schedule to Stop and Start An ADB
Schedule start and stop times for an
Autonomous Database instance
Instance automatically starts and stops
according to the specified schedule
Allows you to reduce costs by scheduling
shutdown periods when a system is not in use

Getting Started workshops for Autonomous Database
https://bit.ly/get-started-with-adb

Low-latency connectivity between Microsoft Azure and OCI
Deploys Oracle Database on OCI, and provides metrics on Azure
Combine the full Azure catalog of AI and application services with OCI’s most powerful database
services
No charges for Oracle Interconnect for Microsoft Azure ports or data ingress/egress over the
Interconnect
Billing normally for consumption of Oracle Database services, such as Autonomous Database
Multicloud with OCI and Azure

Oracle Database Service for Microsoft Azure (ODSA)
Automatically configures
everything required to link the
two cloud environments
Federates Azure active directory
identities
Azure like UI & API experience
for provisioning and managing
Oracle database services on OCI
Sends metrics, logs, and events
for the OCI databases to Azure
tooling for unified telemetry
and monitoring

Collaborative support model
Direct connection between
cloud vendors
<2ms latency for traffic between
OCI and Microsoft Azure
No charges for inbound or
outbound bandwidth consumed

Architecture

For each database product, ODSA supports the common administration and application access capabilities:
• Create, read, update, delete, list (CRUDL)
• Clone database
• Database backup (automatic and manual)
• Database restore (restore to existing database for now)
• Generate Azure connection string
• Display database metrics
Oracle Cloud Infrastructure Integration

Azure tools integration
Delivers OCI database metrics,
events, and logs to tools such as
Azure Application Insights,
Azure Event Grid, and Azure Log
Analytics
Enables Azure users to view OCI
databases alongside the rest of
your Azure data, for unified
telemetry and monitoring
Also creates a custom
dashboard that provides Azure
developers with Oracle
database resource details, and
connection strings for their
applications

Custom dashboard
Displays graphs for each of the
standard Oracle database
metrics for the resource
Give developers and
administrators a quick view of
all metrics in one place

How to use AutoML
with Machine Learning

Oracle Machine Learning Notebooks
Collaborative UI
• Based on Apache Zeppelin
• Supports data scientists, data analysts,
application developers, and DBAs with
SQL and Python
• Easy notebook sharing
• Scheduling, versioning, access control
Included with Autonomous Database
• Automatically provisioned and managed
• In-database algorithms and
analytics functions
• Explore and prepare, build and evaluate
models, score data, deploy solutions
Autonomous Database as a Data Science Platform
Copyright © 2021 Oracle and/or its affiliates.

Automate production and deployment of ML models
• Enhance Data Scientist productivity
and user-experience
• Enable non-expert users to leverage ML
• Unify model deployment and monitoring
• Support model management
Features
• Minimal user input: data, target
• Model leaderboard
• Model deployment via REST
• Model monitoring
• Cognitive features for image and text
AutoML “Code-free” user interface supporting automated end-to-end machine
learning
Copyright © 2020 Oracle and/or its affiliates.

Disaster recovery terminology
Peer Databases: Two or more databases that are linked and replicated
Consist of a Primary database and Standby (copy of the primary) databases
Primary or Source Database: The main database that is actively being
Standby Database: A replica of the primary database which is constantly and
passively refreshing (ie. replicating) data from the primary
Primary Region: The region in which a user first provisions a primary database and enables
cross-region Autonomous Data Guard
Remote Region: The user-selected region in which to provision the standby from a database instance while enabling cross-region
Autonomous Data Guard.
Paired Regions: Two regions that are paired together to support X-ADG, such that a primary database may be provisioned in one of
the regions and its remote standby may be provisioned in the other region.
Recovery Point Objective (RPO): An organization's tolerance for data loss, after which business operations start to get severely
impacted
Recovery Time Object (RTO): An organization's tolerance for the unavailability (or downtime) of a service after which business
operations start to get severely impacted
London Frankfurt

If a regional failure occurs and your primary database is brought down, you may trigger a "Failover" from the remote standby
database to which you want to failover.
Failover across regions to the remote standby
• A failover is a role change - switching control from the primary database to the
standby database
• After a failover, a new remote standby for your new primary will be
automatically provisioned
….when the primary region becomes available again
• During a failover, the system automatically recovers as much data as possible
• Minimizing any potential data loss; there may be a few seconds or minutes of
data loss
• You would usually perform a failover in a true disaster scenario, - accepting
the few minutes of potential data loss to ensure getting your database back
online as soon as possible

Once your remote standby is provisioned, you will see a "Switchover" option on your database's console.
Switchover testing across regions with the remote standby
• Switchover from the remote standby database, while both your primary
and standby are healthy, performs a role change - of the primary
• Switching from the primary database to the remote standby database.
• May take several minutes, depending on the number of changes in the
primary database
• Switchover guarantees no data loss
• You would usually perform a Switchover to test your applications or
mid-tiers against this role change behaviour

ADB Now Supports Cross-Region Clones
Clone an Autonomous Database
instance & select your preferred region
for the clone
Create the clone in the current region
or a remote region
Available regions list limited to regions
you are subscribed to

Reconnect a Disconnected Refreshable Clone
After you disconnect a refreshable clone,
during the following 24-hour period you
can now reconnect that refreshable clone
to the source database
Allows you to use a refreshable clone as a
test database, run DML, and make changes
while the database is disconnected
When you are done with your testing, you
can reconnect to the source database,
which refreshes the clone to the point
where you disconnected.

Export Data as JSON to
Object Storage

ADB now has a procedure to export a query as JSON
directly to Object Storage bucket.
The query can be an advanced query - includes joins
or subqueries.
Specify format parameter with compression option
to compress the output files.
Use DBMS_CLOUD.DELETE_OBJECT to delete the files
BEGIN
DBMS_CLOUD.EXPORT_DATA(
credential_name => 'DEF_CRED_NAME',
file_uri_list =>
‘bucketname/filename’,
query => 'SELECT * FROM DEPT’,
format => JSON_OBJECT('type' value
'json'));
END; /
Export Data As JSON To Object Storage
OVERVIEW HOW IT WORKS

Wallet Rotation and Using TLS
Instead of mTLS or walletless

Per-database with Instance Wallet selected:
• All existing database specific instance wallets will be void.
• Post rotation need to download new wallet to connect to database.
• NOTE - Regional wallets with all database certification keys continue to work
Regional level with Regional Wallet selected:
• Both regional and database specific instance wallets are voided.
• Post rotation need to download new regional or instance wallets to connect to any database in
region
• All user sessions are terminated for databases whose wallet is rotated.
• User session termination begins after wallet rotation completes, however this process does
not happen immediately.
New Option To Rotate Wallets For ADB
1
2

Whats new in Autonomous Database in 2022

mTLS or TLS
Most people do not like to configure wallets
• ADB used mTLS to establish the client-server
connection
• Both the client and the server have a special
secret key and its exchanged to be validated
• Going forward one can connect to ADB using TLS
instead of mTLS
• To make it secure
• To enable TLS on an ADB instance with a public
endpoint exposed
• One must have an Access Control List (ACL) in
place
• Traffic outside of the VCN is blocked giving you
confidence that your connection is secured

Wallet-less connections on Linux x64 clients using Oracle Call Interface
Using TLS authentication for Oracle
Call Interface connections on Linux
x64, a wallet is not required when
the client program connects with
Oracle Instant Client 19.13
Using TLS authentication for Oracle
Call Interface connections on all
other platforms, or without Oracle
Instant Client 19.13, clients must
provide a generic CA root certificate
wallet

Partitions with external
tables in Cloud

• ADB provides transparent access over
data in Object Stores
• Easily join across data sets in the “data
lake” and in-database data sets
• Leverage in-file metadata with Avro,
ORC and Parquet to simplify creating
tables
Autonomous Database – Accessing Data In Object Stores
Object Stores
Oracle Object
Store
Amazon S3
Azure Blob
Store
Autonomous Database
Google Cloud
Store
Wasabi
Cloud Store
41
HOW IT WORKS

Note only use of DBMS_CLOUD syntax is supported
Hybrid Partitioned Tables
BEGIN DBMS_CLOUD.CREATE_HYBRID_PART_TABLE(
table_name =>'HPT1’,
credential_name =>'OBJ_STORE_CRED’,
format => json_object('delimiter' value ',', ‘
recorddelimiter' value 'newline', ‘
characterset' value 'us7ascii’),
column_list => 'col1 number, col2 number, col3 number’
partitioning_clause => 'partition by range (col1)
(partition p1 values less than (1000) external location (
'https://swiftobjectstorage.us-ashburn-1 .../file_01.txt') ,
partition p2 values less than (2000) external location (
‘https://swiftobjectstorage.us-ashburn-1 .../file_02.txt') ,
partition p3 values less than (3000) ) )
END;

External tables with partitioning specified in source files
Partitioning is a well-established technique to improve the performance and manageability of database
systems by dividing large objects into smaller partitions; any large data warehouse takes advantage of it
BEGIN
DBMS_CLOUD.CREATE_EXTERNAL_PART_TABLE(
TABLE_NAME => 'sales_new_api',
CREDENTIAL_NAME => 'CRED_OCI',
FILE_URI_LIST => 'https://objectstorage.us-ashburn-
1.oraclecloud.com/n/my_namespace/b/moviestream_landing/o/sales_sample/*.parquet',
FORMAT => '{"type":"parquet", "schema":
"first","partition_columns":[{"name":"month","type":"varchar2(100)"}]}'
);
END;
/

External tables with partitioning specified in source files
If new files are added or removed in the underlying Object Store, you just run the new sync procedure
like this:
BEGIN
DBMS_CLOUD.SYNC_EXTERNAL_PART_TABLE (table_name => 'sales_new_api');
END;
/

Set Patch Level When Creating A
Clone and retrieve Patch Details

Set Patch Level When Creating A Clone
When you provision or clone an Autonomous
Database instance you can select a patch level to apply
upcoming patches.
There are two patch level options: Regular and Early.
The Early patch level allows testing upcoming patches one
week before they are applied as part of the regular patching
program
The console shows the patch level setting with the section
headed Maintenance.

View Autonomous Database maintenance event history to see details about past maintenance events
(requires ADMIN user)
View Patch Details OVERVIEW

SELECT * FROM DBA_CLOUD_PATCH_INFO;
SELECT * FROM DBA_CLOUD_PATCH_INFO WHERE PATCH_VERSION = 'ADBS-21.7.1.2';
View Patch Details HOW IT WORKS

Oracle Database API for
MongoDB

Oracle Database API for MongoDB
enables developers to connect
applications directly to Oracle
Autonomous Database using MongoDB's
own drivers and tools
Oracle Database API for MongoDB
Developers can combine existing
MongoDB skills with full power of
Autonomous Database

OCI Identity and Access
Management (IAM)
Authentication

Integration With OCI Identity and Access Management (IAM) Authentication
OCI Identity and Access Management users can now
authenticate and authorize to ADB-Shared.
Better security since user access to databases is managed
centrally instead of locally in every database
Reduces zombie database user accounts
User management moves DBA tasks to the IAM administrator
SQL*Plus users can sign into Autonomous Database using their
IAM username and IAM database password
Users can also use IAM SSO tokens with the latest JDBC-thin
and OCI-C database clients to connect with ADB-Shared

Change Concurrency
Limits Via Console

Override the default concurrency settings via
the MEDIUM service.
Makes it easier to manage application-specific
concurrency requirements.
Change via Autonomous Database Service
Console or using PL/SQL procedure
Change Concurrency Limits Via Console

1. Enable Azure service principal authentication in ADB-S
Simplified access to resources on Azure
SQL> BEGIN
2 DBMS_CLOUD_ADMIN.ENABLE_PRINCIPAL_AUTH(
3 provider => 'AZURE',
4 params => JSON_OBJECT('azure_tenantid' value '74***-****-****-****-****67'));
5 END;
6 /
PL/SQL procedure successfully completed.
Enable the Azure service principal authentication in ADB-S instance
Needs Azure Active Directory (AD) tenant ID for this so that my ADB-S instance can be properly associated with my
Azure tenancy and registered as an authorized application in
see How to find your Azure Active Directory tenant ID

2. Provide Azure application consent
SQL> SELECT param_name, param_value FROM CLOUD_INTEGRATIONS;
PARAM_NAME PARAM_VALUE
------------------ -----------------------------------------------------------------------
-------
azure_tenantid 74***-****-****-****-****67
azure_consent_url https://login.microsoftonline.com/'74***-****-****-
****_****67'/oauth2/v2.0/***&scope=User.read
azure_app_name ADBS_APP_OCID1.AUTONOMOUSDATABASE.OC1.IAD.******VFA
Query the CLOUD_INTEGRATIONS view to find the azure_consent_url and azure_app_name

3. Provide Azure application consent
Visit the URL from azure_consent_url and accept the request:

4. Assign necessary roles for the application to access the Azure resources
Navigate to Azure console home -> Storage accounts -> <myStorageAccountname> -> Access Control (IAM) ->
Add -> Add Role Assignment -> Role and search for “blob storage”

4. Assign necessary roles for the application to access the Azure resources
Navigate to Members -> Select members and copy/paste the the value of azure_app_name

5. Load data from Azure blob storage via Azure service principal
Load some data from my Azure blob storage
AZURE$PA is the credential_name in DBMS_CLOUD.COPY_DATA procedure:
SQL> CREATE TABLE CHANNELS
2 (channel_id CHAR(1),
3 channel_desc VARCHAR2(20),
4 channel_class VARCHAR2(20)
5 );
Table CHANNELS created.
SQL> BEGIN
2 DBMS_CLOUD.COPY_DATA(
3 table_name =>'CHANNELS',
4 credential_name =>'AZURE$PA',
5 file_uri_list =>'https://ctuzlastorage.blob.core.windows.net/ctuzlabucket/chan_v3.dat',
6 format => json_object('ignoremissingcolumns' value 'true', 'removequotes' value 'true')
7 );
8 END;
9 /
SQL> select count(*) from channels;
COUNT(*)
___________
10

Use Azure Active Directory to centrally manage database users
Autonomous Database (Shared
Infrastructure) users can be
centrally managed in Microsoft
Azure Active Directory (Azure
AD) for stronger security instead
of locally in every database
Azure AD users and applications
can use Azure AD OAuth2
access tokens to access the
Autonomous Database
Azure AD users don't have to
remember separate database
credentials; they use their
existing Azure AD SSO
credentials

Connect to non-Oracle
Databases

Step-1: Make Sure Redshift is Configured to Allow Public Access
Connect to Non-Oracle databases using built-in heterogeneous connectivity
Under “Actions” menu of your Redshift cluster on AWS console, we need to select “Modify publicly accessible
setting” to make sure our Redshift cluster is publicly accessible:

Step-1: Make Sure Redshift is Configured to Allow Public Access
We then navigate to the VPC security group that is assigned to our Redshift cluster and create an inbound rule to
port 5439 from the source IP or CIDR range of our choice:

Step-2: Create a Database Link to your Redshift Instance
First, create a credential object with the credentials (username and password) of the target database:
BEGIN
DBMS_CLOUD.CREATE_CREDENTIAL(
credential_name => 'REDSHIFT_CRED’,
username => 'awsadmin’,
password => '************’);
END;
/

Step-2: Create a Database Link to your Redshift Instance
Next, we will create a database link to our Redshift instance. As you can tell, it looks nearly identical to any other
database link creation except for the gateway_params parameter for which we are passing 'awsredshift' as our
database type:
BEGIN
DBMS_CLOUD_ADMIN.CREATE_DATABASE_LINK(
db_link_name => 'REDSHIFT_LINK',
hostname => 'redshift-cluster-1.******.us-west-1.redshift.amazonaws.com',
port => '5439',
service_name => 'dev',
credential_name => 'REDSHIFT_CRED',
gateway_params => JSON_OBJECT('db_type' value 'awsredshift'),
ssl_server_cert_dn => NULL);
END;
/

Step-3: Run a Query Over the Database Link
SELECT COUNT(*) FROM SALES@REDSHIFT_LINK;
COUNT(*)
-----------
172456

ADB provides two options for Transparent Data Encryption (TDE) to encrypt data in the database:
• Oracle-managed encryption keys
• Customer-managed encryption keys
• Customer managed keys integrates with Oracle Cloud Infrastructure Vault service
• When rotating customer-managed master encryption key ADB generates a new TDE master key
• ADB uses new TDE master key to re-encrypt tablespace encryption keys that encrypt and decrypt your data.
• Operation is fast and does not require database downtime
Customer Managed Keys
OVERVIEW

Customer Managed Keys
HOW IT WORKS

Use Resource Principal
To Access OCI Resources

A resource principle authorizes an OCI resource to make API calls to certain OCI services (e.g. Object Store)
This simplifies access to Object Stores
Autonomous Database can use resource principal credentials to access the specified Oracle Cloud
Infrastructure resources.
Typical use cases:
• Access data from an Object Storage bucket, perform some operation on the data, and then write the modified data back to
the Object Storage bucket.
• Access your vaults, keys, or secrets.
• List work requests or list work request errors.
Use Resource Principal To Access OCI Resources
OVERVIEW

1) Create a dynamic group
Tells IAM that a given Autonomous Database should be able to read from the Object
Storage buckets and objects that are in a given compartment
HOW IT WORKS
In the OCI console, go to ‘Identity and Security’ -> ‘Dynamic Groups’ -> ‘Create Dynamic Group’
To include only ADB-S instance to this dynamic group, add the instance OCID in the following rule:
resource.id = 'ocid1.autonomousdatabase.oc1.iad.osbgdthsnmakytsbnjpq7n37q'

HOW IT WORKS

2) Create a policy
Allow this resource to access our Object Storage bucket that resides in a given compartment
HOW IT WORKS
In the OCI console, go to ‘Identity and Security’ -> ‘Policies’-> ‘Create Policy’
Add your policy statement in plain text or use the Policy Builder.
Allow dynamic-group ctuzlaDynamicGroup to read buckets in compartment ctuzlaRPcomp
Allow dynamic-group ctuzlaDynamicGroup to read objects in compartment ctuzlaRPcomp
Note: It’s also possible to allow higher levels of access as described in the documentation

3) Enable resource principal in ADB-S
Resource principal is not enabled by default in ADB-S.
In order to be able to use resource principal in our ADB-S instance, we need to enable it using
the DBMS_CLOUD_ADMIN.ENABLE_RESOURCE_PRINCIPAL procedure:
HOW IT WORKS
As ADMIN user, execute the following statement:
EXEC DBMS_CLOUD_ADMIN.ENABLE_RESOURCE_PRINCIPAL();

4) Verify that resource principle is enabled:
HOW IT WORKS
SELECT owner, credential_name
FROM dba_credentials
WHERE credential_name = 'OCI$RESOURCE_PRINCIPAL' AND owner = 'ADMIN';
OWNER CREDENTIAL_NAME
----- ----------------------
ADMIN OCI$RESOURCE_PRINCIPAL

5) Optionally, enable other database users to call DBMS_CLOUD APIs using resource principal
HOW IT WORKS
EXEC DBMS_CLOUD_ADMIN.ENABLE_RESOURCE_PRINCIPAL(username => 'ADB_USER');

6) Load data from Object Storage using resource principal
HOW IT WORKS
CREATE TABLE CHANNELS
(channel_id CHAR(1),
channel_desc VARCHAR2(20),
channel_class VARCHAR2(20)
);
Table CHANNELS created.
BEGIN
DBMS_CLOUD.COPY_DATA(
table_name =>'CHANNELS',
credential_name =>'OCI$RESOURCE_PRINCIPAL',
file_uri_list =>'https://objectstorage.us-ashburn-
1.oraclecloud.com/n/adwc4pm/b/ctuzlaBucket/o/chan_v3.dat',
format => json_object('ignoremissingcolumns' value 'true', 'removequotes' value 'true')
);
END;
/

Load data using DBMS_CLOUD
• For data loading from files in the Cloud
• Store your object storage credentials
• Use the procedure DBMS_CLOUD.COPY_DATA to load data
• The source file in this example is channels.txt
File-02 in
Object Store
Bucket
File-03 in
Object Store
Bucket
File-01 in
Object Store
Bucket
SET DEFINE OFF BEGIN
DBMS_CLOUD.CREATE_CREDENTIAL(
credential_name => 'DEF_CRED_NAME',
username => 'adwc_user@example.com',
password => 'password' ); END; /

CREATE TABLE CHANNELS (channel_id CHAR(1), channel_desc VARCHAR2(20),
channel_class VARCHAR2(20) );
BEGIN DBMS_CLOUD.COPY_DATA( table_name =>'CHANNELS', credential_name
=>'DEF_CRED_NAME’,
file_uri_list =>
'https://objectstorage.us-phoenix-1.oraclecloud.com/n/namespace-string/b/
bucketname/o/channels.txt', format => json_object('delimiter' value ',') );
END;
BEGIN DBMS_CLOUD.COPY_DATA( table_name =>'CHANNELS', credential_name
=>'DEF_CRED_NAME’,
file_uri_list =>'https://objectstorage.us-phoenix-1.oraclecloud.com/n/namespace-
string/b/
bucketname/o/exp01.dmp,
https://objectstorage.us-phoenix-1.oraclecloud.com/n/namespace-string/b/
bucketname/o/exp02.dmp', format => json_object('type' value 'datapump') );
END;

BEGIN DBMS_CLOUD.COPY_COLLECTION( collection_name => 'fruit', credential_name =>
'DEF_CRED_NAME', file_uri_list => 'https://objectstorage.us-ashburn-1.oraclecloud.com/n/
namespace-string/b/fruit_bucket/o/myCollection.json’,
format => JSON_OBJECT('recorddelimiter' value '''n''') );
END;
BEGIN DBMS_CLOUD.COPY_COLLECTION( collection_name => 'fruit2', credential_name =>
'DEF_CRED_NAME', file_uri_list => 'https://objectstorage.us-ashburn-1.oraclecloud.com/n/
namespace-string/b/json/o/fruit_array.json’,
format => '{"recorddelimiter" : "0x''01''", "unpackarrays" : TRUE}' );
END;

SELECT table_name, owner_name, type, status, start_time, update_time,
logfile_table, badfile_table FROM user_load_operations WHERE
type = 'COPY’;
TABLE_NAME OWNER_NAME TYPE STATUS START_TIME UPDATE_TIME LOGFILE_TABLE BADFILE_TABLE
------------------------------------------------------------------------------------
FRUIT ADMIN COPY COMPLETED 2020-04-23 22:27:37 2020-04-23 22:27:38 "" ""
FRUIT ADMIN COPY FAILED 2020-04-23 22:28:36 2020-04-23 22:28:37 COPY$2_LOG COPY$2_BAD
SELECT credential_name, username, comments FROM all_credentials;
CREDENTIAL_NAME USERNAME COMMENTS
---------------------------–----------------------------- --------------------
ADB_TOKEN user_name@example.com {"comments":"Created via
DBMS_CLOUD.create_credential"}
DEF_CRED_NAME user_name@example.com {"comments":"Created via
DBMS_CLOUD.create_credential"}

ADB now supports SQL
access to tenancy details

88 Confidential – © 2019 Oracle Internal/Restricted/Highly Restricted
When you file a service request for Autonomous Database, you need to provide the tenancy details for your
instance. Tenancy details for the instance are available on the Oracle Cloud Infrastructure console.
However, if you are connected to the database, you can now obtain these details by querying
the CLOUD_IDENTITY column of the V$PDBS view. For example:
...will generate something similar to the following:
How to get the tenancy details for your instance
SELECT cloud_identity FROM v$pdbs;
{"DATABASE_NAME" : "DBxxxxxxxxxxxx",
"REGION" : "us-phoenix-1",
"TENANT_OCID" :
"OCID1.TENANCY.REGION1..ID1",
"DATABASE_OCID" :
"OCID1.AUTONOMOUSDATABASE.OC1.SEA.ID2
",
"COMPARTMENT_OCID" :
"ocid1.tenancy.region1..ID3"}

UI Button To Quickly Add Your IP Address To ACLs
Makes it easier to setup ACLs where you need to add the IP
address of the client to your Network Access Control List (ACL)
The button "Add My IP Address" adds your current IP address
to the ACL entry
Removes the need to manually look for your client IP via a 3rd
party website or app anymore (e.g. Google, whatsmyip.com
etc)
Available in both the Create Autonomous Database flow for
new ADB-S instances to be provisioned and the Update
Network Access flow for existing ADB-S instances

Thank You
Any Questions ?
Sandesh Rao
VP AIOps for the Autonomous Database
@sandeshr
https://www.linkedin.com/in/raosandesh/
https://www.slideshare.net/SandeshRao4

Whats new in Autonomous Database in 2022

More Related Content

What's hot (20)

Similar to Whats new in Autonomous Database in 2022 (20)

More from Sandesh Rao (20)

Recently uploaded (20)

Whats new in Autonomous Database in 2022