Comment créer une application PDB – Le blog des bases de données

CRÉER UNE APPLICATION PDB BASE DE DONNÉES

Les « conteneurs d'application » sont une fonctionnalité de la version 12.2. Un « conteneur d'application » est un composant CDB facultatif permettant de stocker les données et les métadonnées d'une application. Un CDB peut comporter zéro ou plusieurs conteneurs d'application. Chaque application est composée d'une configuration, de métadonnées et d'objets partagés. On peut donc le définir comme un conteneur d’applications partagées, pouvant héberger différentes versions d’une même application.

Les conteneurs d’applications peuvent être créés de différentes manières : à partir d’une base de données PDBD seed, en clonant des PDB, en les connectant ou en les déconnectant d’ PDB, mais dans tous les cas, on utilise la commande CREATE PLUGGABLE DATABASE, en incluant la clause « APPLICATION CONTAINER ». Pour créer un conteneur d’application, vous devez être connecté à la racine de la base de données centrale (CDB), celle-ci doit être ouverte en mode « lecture-écriture », et le nom du conteneur d’application doit être unique.

1) Déclaration de création de la base de données en tant que conteneur d'application.

À titre d'exemple, nous allons créer un conteneur d'application pour les jouets que nous appellerons "toys_root".

CREATE PLUGGABLE DATABASE toys_root AS APPLICATION CONTAINER
ADMIN USER admin identified by ****
ROLES=(CONNECT)
oracle;
/

2) Grâce à la requête suivante, nous pouvons vérifier quels types de PDB nous avons créés dans notre architecture.

Le résultat indiquera que notre « Application PDB » est définie sur « Application root » avec la valeur « YES ».

3) Nous ouvrons la base de données que nous venons de créer.

alter pluggable database TOYS_ROOT open ;

Une fois l'Application Container créé PDB, nous pouvons désormais tester la gestion des versions de l'application et la manière dont ces versions peuvent être répliquées entre les différentes bases de données.

4) Nous avons créé une version mobile de l'PDB.

Une fois connectés à l'PDB , nous exécutons TOYS_ROOT.

ALTER PLUGGABLE DATABASE application TOYS_APP begin install '1.0' ;

Nous lui demandons ainsi de créer une version d'une application que nous appellerons TOYS_APP et dont la version sera 1.0.

5) Nous vérifions que le CBD a été créé correctement.

select app_name, app_version, app_status
from dba_applications
where app_name='TOYS_APP' ;

6) Nous créons un tbs de test, un utilisateur et lui donnons les permissions nécessaires :

set echo on
create tablespace toys_tbs datafile size 100M autoextend on next 10M maxsize 200M;
create user toys_owner identified by **** container=all;
grant create session, dba to toys_owner;
alter user toys_owner default tablespace toys_tbs;

Nous créons une nouvelle table afin de vérifier qu'elle se réplique correctement. Il s'agira de la version 1.0. de notre application TOYS_APP.

SQL> CREATE TABLE toys_owner.raul (one number, two varchar(2)) ;
Table créée.
SQL> insert into toys_owner. raul values(1,'r') ;
1 ligne créée.
SQL> commit ;
Commit terminé.

7) Fermez l'installation de l'"application".

ALTER PLUGGABLE DATABASE application TOYS_APP end install '1.0' ;

8) Nous vérifions maintenant l'état de la demande

select app_name, app_version, app_status
from dba_applications
where app_name='TOYS_APP';

APP_NAME APP_VERSION APP_STATUS
-------------------------------
TOYS_APP 1.0 NORMAL

9) Réplication entre conteneurs

Pour effectuer le test, nous allons créer deux nouveaux PDBS, dans ce cas "robots" et "poupées".

CREATE PLUGGABLE database robots
admin user admin identified by ***
CREATE_FILE_DEST=
'/u02/app/oracle/oradata/ORCL/toys_root/robots'
Pluggable database created.

SQL> alter pluggable database robots open;
Pluggable database altered.

CREATE PLUGGABLE database dolls
admin user admin identified by ***
CREATE_FILE_DEST=
oracle;

SQL> alter pluggable database dolls open;
Base de données pluggable modifiée.

SQL> show pdbs
CON_ID CON_NAME OPEN MODE RESTRICTED
2 PDB$SEED LECTURE SEULE NON
3 TOYS_ROOT LECTURE ÉCRITURE NON
4 PDB1 LECTURE ÉCRITURE NON
5 TOYS_ROOT$SEED LECTURE ÉCRITURE NON
6 ROBOTS LECTURE ÉCRITURE NON
7 DOLLS LECTURE ÉCRITURE NON

Nous allons maintenant dans les conteneurs nouvellement recréés pour effectuer la synchronisation de notre application.

Nous passons au conteneur ROBOTS et rafraîchissons l'application, dans ce cas tst_app

SQL> ALTER SESSION SET CONTAINER=ROBOTS;

Session altered.

SQL> ALTER PLUGGABLE DATABASE APPLICATION TOYS_APP SYNC ;

Pluggable database altered.

Nous vérifions que le tableau a été actualisé

SQL> show con_name

CON_NAME
------------------------------
ROBOTS

SQL> DESC TOYS_OWNER.RAUL
Name                               Null?    Type
---------------------------------- -------- -----------------------
UNO                                         NUMBER
DOS                                         VARCHAR2(2)


SQL> select * from toys_owner.raul;

       UNO DO
---------- --
	 1 r

Nous allons effectuer la même opération de synchronisation sur l'autre PDB.

SQL> ALTER SESSION SET CONTAINER=DOLLS ;
Session modifiée.

Et nous effectuons la même opération. Nous synchronisons l'application :

SQL> ALTER PLUGGABLE DATABASE APPLICATION TOYS_APP SYNC ;
Base de données enfichable modifiée.

Nous vérifions que la table a été répliquée :

SQL> desc toys_owner.raul
Nom Null ? Type
UNO NUMBER
DOS VARCHAR2(2)

SQL> select * from toys_owner.raul ;
UNO DO
1 r

A tout moment vous pourrez connaître l'état de votre APP, son état et sa version

Vous pouvez le vérifier avec une requête similaire à la suivante, où vous indiquez le nom de l'APP, son id, son état, si elle est implicite ou non, etc.

select app_name, app_version, app_id, app_status,
app_implicit implicit
from dba_applications ;

APP_NAME APP_VERSION APP_ID APP_STATUS I
---------------------------------------- ------------------------------ ---------- ------------ -
TOYS_APP 1.0 2 NORMAL N

10) Mettre à jour notre APP.

Une fois que nous avons créé et testé le fonctionnement du conteneur d'application, nous pouvons créer différentes versions de celui-ci, ou supprimer une version de l'APP lorsqu'elle n'est plus valide.

Pour mettre à jour la version de notre APP, nous devons utiliser les commandes begin upgrade / end upgrade, bien sûr à l'intérieur de APP_ROOT.

SQL> alter pluggable database application TOYS_APP1 begin upgrade '1.0' to '1.1' ;
Pluggable database altered.

SQL> insert into toys_owner. raul values(2,'d') ;
1 row created.
SQL> commit ;
Commit complete.

SQL> alter pluggable database application TOYS_APP1 end upgrade ;
Base de données enfichable modifiée.

SQL> alter session set container=DOLLS ;
SQL> ALTER PLUGGABLE DATABASE APPLICATION TOYS_APP1 SYNC ;
Base de données enfichable modifiée.

 SQL> SELECT * FROM TOYS_OWNER.RAUL ;
   ONE TWO
---------- --
     1 r
     2 d

11) Désinstallation d'une application

Pour désinstaller une application, il faut effectuer les opérations suivantes :

SQL> ALTER PLUGGABLE DATABASE APPLICATION TOYS_APP BEGIN UNINSTALL ;
Base de données enfichable modifiée.

SQL> drop user toys_owner cascade ;
utilisateur supprimé.

SQL> drop tablespace TOYS_TBS INCLUANT CONTENU ET DATAFILES ;
tablespace abandonné

SQL> ALTER PLUGGABLE DATABASE APPLICATION TOYS_APP END UNINSTALL ;
Base de données enfichable modifiée.

En résumé, Oracle nous permet de disposer de « versions » de différentes applications, qui peuvent être synchronisées via PDB, mises à jour, clonées, etc.

Tags : RDBMSOracle

Actualités connexes

Vous pouvez être intéressé par