Afrikaans
Akan
Albanian
Amharic
Armenian
Azerbaijani
Basque
Belarusian
Bemba
Bengali
Bihari
Bosnian
Breton
Bulgarian
Cambodian
Catalan
Cebuano
Cherokee
Chichewa
Chinese (Simplified)
Chinese (Traditional)
Corsican
Croatian
Czech
Danish
Dutch
English
Esperanto
Estonian
Ewe
Faroese
Filipino
Finnish
French
Frisian
Ga
Galician
Georgian
German
Greek
Guarani
Gujarati
Haitian Creole
Hausa
Hawaiian
Hebrew
Hindi
Hmong
Hungarian
Icelandic
Igbo
Indonesian
Interlingua
Irish
Italian
Japanese
Javanese
Kannada
Kazakh
Kinyarwanda
Kirundi
Kongo
Korean
Krio (Sierra Leone)
Kurdish
Kurdish (Soranรฎ)
Kyrgyz
Laothian
Latin
Latvian
Lingala
Lithuanian
Lozi
Luganda
Luo
Luxembourgish
Macedonian
Malagasy
Malay
Malayalam
Maltese
Maori
Marathi
Mauritian Creole
Moldavian
Mongolian
Myanmar (Burmese)
Montenegrin
Nepali
Nigerian Pidgin
Northern Sotho
Norwegian
Norwegian (Nynorsk)
Occitan
Oriya
Oromo
Pashto
Persian
Polish
Portuguese (Brazil)
Portuguese (Portugal)
Punjabi
Quechua
Romanian
Romansh
Runyakitara
Russian
Samoan
Scots Gaelic
Serbian
Serbo-Croatian
Sesotho
Setswana
Seychellois Creole
Shona
Sindhi
Sinhalese
Slovak
Slovenian
Somali
Spanish
Spanish (Latin American)
Sundanese
Swahili
Swedish
Tajik
Tamil
Tatar
Telugu
Thai
Tigrinya
Tonga
Tshiluba
Tumbuka
Turkish
Turkmen
Twi
Uighur
Ukrainian
Urdu
Uzbek
Vietnamese
Welsh
Wolof
Xhosa
Yiddish
Yoruba
Zulu
In this lesson, we want to examine
the concept of container databases, or CDB.
Even if you're familiar with the Oracle Database,
you may be unfamiliar with the concept of container databases
because they're brand new in Oracle 12c.
They are a core part of Oracle 12c's new Multitenant
Architecture.
The Multitenant Architecture is intended
to market the Oracle Database toward the Cloud computing
market but it also serves as a type of virtualization.
So with server virtualization, we're
allowed to take a certain finite number of physical servers
and provide an almost endless supply of virtual machines,
or VMs.
So if we have three physical servers
and we need 100 virtual servers, we can simply virtualize those.
Oracle's Multitenant Architecture
does something very similar at the database level.
So we could think of it as database virtualization--
the idea of a finite number of databases
that host a large number of virtualized databases.
So the problem we're attempting to deal with here
is something we could term "database sprawl."
We have the term "server sprawl" in the hardware industry
to indicate that we're continually
purchasing more and more servers to meet customer needs
or meet business needs.
We can also have the same type of thing with databases.
So let's say that we have three basic production databases--
one for our HR functions, one for our customer relationship
management database, and another for our financials.
That in itself is not too big of a problem.
But we have to add that to the fact
that we might also have a development
database for the HR.
We might have a test database, as well.
Then, we might have a database for legacy information.
Add to the fact that we have these,
as well, for our CRM database and our financials.
So we can see, just in the supporting
of three applications--
HR, CRM, and financials, that we're already
experiencing database sprawl--
the proliferation of databases required
to meet business needs.
Every one of these databases has to be managed.
Its space has to be managed, it has to be performance tuned,
it has to be patched, it has to be upgraded.
All of these standard DBA functions
have to be done for each one of these databases
and that can create a problem for database teams.
So what's the answer?
Well, the answer lies in Multitenant Container Databases
in Oracle 12c.
In the Multitenant Architecture, we build our databases
differently.
So rather than having numerous separate databases,
we create a finite, or small number, of container databases,
or CDBs.
So we might have a prod container
database, one for development, and one for test.
And we build our databases within these containers.
So our production HR, production financials, and production CRM
are all in the prod container database.
Then we do the same thing for the development databases
for each one of our applications.
We do the same for test, as well.
We're still presenting the same number of databases
but we're only managing the container databases themselves.
So now, instead of, in this case, nine different sets
of patching, performance tuning, storage management,
being responsible for all of those types of things,
we're instead responsible for managing the container
databases.
And the changes trickle down to these other databases.
And we call these pluggable databases.
So the characteristics of a container database
is that it acts as the root database
and it contains PDBs, or pluggable databases.
So the pluggable databases are the databases
that appear to the application.
A container database can also contain a seed database,
which is a template for quickly creating other PDBs,
pluggable databases.
So seed databases allow us to be able to create a new database
from a template and a matter of minutes
instead of a matter of hours.
Can't find what you're looking for?
Get subtitles in any language from opensubtitles.com, and translate them here.