Learn about schemas, their permissions, and how to use them. - MaxCompute

Les schémas permettent d'organiser les tables, les ressources et les fonctions en groupes logiques au sein d'un projet MaxCompute pour une gestion plus fine.

Contexte

Un projet MaxCompute constitue l'unité organisationnelle de base et la principale limite pour l'isolation multi-utilisateurs et le contrôle d'accès.

Un projet contient des tables, des ressources et des fonctions. Auparavant, ces objets étaient placés directement sous un projet, qui devait servir à la fois de base de données et de schéma. Cette configuration rendait la gestion difficile lorsque le projet contenait de nombreux objets. MaxCompute prend désormais en charge les schémas, qui classent les tables, les ressources et les fonctions au sein d'un projet. La figure suivante illustre la hiérarchie. 层级图

Portée

La fonctionnalité de schéma est en cours d'amélioration continue. Certains modules n'ont pas encore été adaptés et ne peuvent être utilisés qu'en mode set odps.namespace.schema=false.

Outils de développement
- Le client MaxCompute v0.40.8 et versions ultérieures prend en charge la fonctionnalité de schéma.
- Le plug-in MaxCompute Studio 4.0.0 et versions ultérieures prend en charge la fonctionnalité de schéma.
Types de tâches
- Les tâches Spark 3.1.1 et versions ultérieures prennent en charge la fonctionnalité de schéma.
- Définissez le paramètre suivant pour les tâches Spark :
```
spark.sql.catalog.odps.enableNamespaceSchema=true
```
- Les tâches Mars et MapReduce ne prennent pas en charge la fonctionnalité de schéma.
Autres produits cloud
- Hologres V1.3 et versions ultérieures prend en charge la fonctionnalité de schéma. Pour mettre à niveau une instance Hologres, consultez la rubrique Mettre à niveau une instance.
- D'autres produits cloud, tels que PAI et Quick BI, ne prennent pas en charge la fonctionnalité de schéma personnalisé.
Java SDK 0.40.8 et versions ultérieures, Java Database Connectivity (JDBC) 3.3.2 et versions ultérieures, ainsi que PyODPS 0.11.3.1 et versions ultérieures prennent en charge la fonctionnalité de schéma.
DataWorks peut interagir avec les schémas dans MaxCompute uniquement après avoir activé la fonctionnalité de schéma au niveau du locataire ou du projet. Pour plus d'informations, consultez la rubrique Prise en charge des schémas MaxCompute par DataWorks.
Les vues et les fonctions définies par l'utilisateur (UDF) créées en mode odps.namespace.schema=false sont accessibles uniquement dans ce même mode. La même règle s'applique au mode odps.namespace.schema=true.

Termes clés

Schéma

Un schéma classe les tables, les ressources et les UDF au sein d'un projet. Un projet peut contenir plusieurs schémas.
Commutateur de syntaxe de schéma

Lorsque vous activez le commutateur de syntaxe de schéma, le système analyse les instructions en utilisant la sémantique project.schema.table.
- Lorsque la syntaxe de schéma est activée, une instruction au format a.b.c est analysée comme project.schema.table. Une instruction au format a.b est analysée comme schema.table.
- Lorsque la syntaxe de schéma est désactivée, une instruction au format a.b.c n'est pas reconnue. Une instruction au format a.b est analysée comme project.table. Ce commutateur peut être défini au niveau du locataire et au niveau de la tâche.
Schéma par défaut

Lorsque la fonctionnalité de schéma est activée, un schéma intégré nommé DEFAULT est automatiquement créé dans chaque projet. Vous ne pouvez pas supprimer ce schéma.
Paramètre au niveau du locataire

Détermine la sémantique par défaut pour les demandes d'accès aux données soumises par l'ensemble du locataire.
Paramètre au niveau de la tâche

Ce paramètre affecte uniquement la tâche en cours et est prioritaire sur le paramètre au niveau du locataire. Exécutez la commande set odps.namespace.schema=true | false; pour activer ou désactiver la syntaxe de schéma.

Activer la fonctionnalité

Si vous débutez avec MaxCompute et ne disposez d'aucun projet existant, activez le commutateur de syntaxe au niveau du locataire. Tous les nouveaux projets prendront alors en charge la fonctionnalité de schéma, et toutes les demandes seront analysées par défaut selon la syntaxe odps.namespace.schema = true.
1. Connectez-vous à la console MaxCompute et sélectionnez une région dans le coin supérieur gauche.
2. Dans le volet de navigation de gauche, choisissez Manage Configurations > Tenants .
3. Sur la page Tenants, cliquez sur l'onglet Tenant Property.
4. Sous l'onglet Tenant Property, activez le commutateur Tenant-level Schema Syntax.
Si vous disposez de 10 projets existants ou moins et de peu ou pas de tâches existantes, suivez ces étapes pour adapter votre environnement. Après l'adaptation, les nouveaux projets prendront en charge les schémas et toutes les demandes seront analysées par défaut selon la syntaxe odps.namespace.schema=true.
1. Commencez par mettre à niveau tous les projets existants pour qu'ils prennent en charge les schémas.
  1. Connectez-vous à la console MaxCompute et sélectionnez une région dans le coin supérieur gauche.
  2. Dans le volet de navigation de gauche, choisissez Manage Configurations > Projects.
  3. Sur la page Projects, cliquez sur Enable Schema dans la colonne Actions pour le projet cible.
2. Ensuite, activez l'option Tenant-level Schema Syntax.
  1. Dans le volet de navigation de gauche, choisissez Manage Configurations > Tenants .
  2. Sur la page Tenants, cliquez sur l'onglet Tenant Property.
  3. Sous l'onglet Tenant Property, activez le commutateur Tenant-level Schema Syntax.
Si vous disposez de projets et de tâches existants et devez mettre à niveau des projets spécifiques pour qu'ils prennent en charge les schémas, suivez ces étapes. Après la mise à niveau, un Schema nommé DEFAULT est créé par défaut dans le projet.
1. Connectez-vous à la console MaxCompute et sélectionnez une région dans le coin supérieur gauche.
2. Dans le volet de navigation de gauche, choisissez Manage Configurations > Projects.
3. Sur la page Projects, cliquez sur Enable Schema dans la colonne Actions pour le projet cible.
4. Toutes les demandes sont analysées par défaut selon la syntaxe odps.namespace.schema = false. Pour un projet mis à niveau, après avoir créé un schéma personnalisé, vous devez activer la syntaxe de schéma au niveau de la tâche en exécutant set odps.namespace.schema=true; afin d'accéder aux données du schéma personnalisé.
- Si la syntaxe de schéma est activée, le chemin d'accès aux données pour un projet non mis à niveau est projectname.default.tablename.
- Si la syntaxe de schéma est désactivée, un projet mis à niveau ne peut pas accéder aux schémas personnalisés. Le chemin projectname.tablename reconnaît uniquement les données du Schema nommé DEFAULT.

Remarques d'utilisation

Créer un projet

Avant d'utiliser les schémas, vous devez créer un projet MaxCompute.
Lorsque vous créez un projet dans la console MaxCompute, si le commutateur de syntaxe au niveau du locataire est activé (odps.namespace.schema = true), le projet prend en charge les schémas par défaut.

Gérer les schémas

Gérer les schémas à l'aide de commandes

Afficher la liste des schémas
```
SHOW schemas;
```
Créer un schéma
```
CREATE schema <schema_name>;
```
schema_name spécifie le nom du schéma personnalisé.
Afficher les informations relatives au schéma
```
DESC schema <schema_name>;
```
schema_name spécifie le nom du schéma.
Supprimer un schéma
```
DROP schema <schema_name>;
```
schema_name spécifie le nom du schéma.

Gérer les schémas à l'aide de la console de gestion

Connectez-vous à la console MaxCompute et sélectionnez une région dans le coin supérieur gauche.
Dans le volet de navigation de gauche, choisissez Manage Configurations > Projects.
Sur la page Projects, cliquez sur Manage dans la colonne Actions pour le projet cible.
Sur la page Project Settings, cliquez sur l'onglet Schema.

L'onglet Schema n'est visible que pour les projets qui prennent en charge les schémas.
Sous l'onglet schema, vous pouvez afficher la liste des schémas, ainsi que créer ou supprimer des schémas.

Effectuer des opérations sur les objets d'un schéma

Utilisez le format project.schema.table pour référencer les objets d'un schéma.

Remarque

Les références aux objets Table dans cette rubrique s'appliquent également aux objets View, Resource et Function.

Lorsque vous effectuez des opérations sur une table entre différents projets, vous devez utiliser le format de commande complet : project.schema.table.
Pour les opérations inter-schémas au sein du même projet, vous pouvez utiliser le format schema.table. Si une commande est au format a.b, a est analysé comme le schéma, b est analysé comme la table, et le projet correspond au projet actuel.
Au sein du même projet, vous pouvez exécuter la commande use schema <schema_name> pour spécifier le schéma actuel. Vous pouvez ensuite utiliser directement une commande telle que select * from a. Dans ce cas, a représente la table, qui est automatiquement résolue vers le projet actuel et le schéma spécifié.
Si aucun schéma n'est spécifié dans le contexte et que vous utilisez une commande telle que select * from a, a représente la table. Elle est automatiquement résolue vers le projet actuel et le schéma nommé default.

Exemples

Exemple 1 : Effectuer des opérations sur les objets d'un schéma au sein du même projet (projectA).

Effectuer des opérations sur les objets du schéma default.

use projectA;
set odps.namespace.schema=true;-- If this is set at the tenant level, you do not need to specify it here.
-- Operate on table t_a
create table t_a(c1 string,c2 bigint);
INSERT OVERWRITE TABLE t_a VALUES ('a',1),('b',2),('c',3);
select * from t_a;
show tables;
desc t_a;

tunnel upload <path> t_a[/<pt_spc>];
tunnel download t_a[/pt_spc] <path>;

-- Operate on resource res_a.jar
add jar <path>/res_a.jar ;
desc resource res_a.jar;
list resources;
get resource res_a.jar D:\;
drop resource res_a.jar;

-- Operate on function fun_a
 create function fun_a as 'xx' using 'res_a.jar';
 desc function fun_a;
 list functions;
 drop function fun_a;

Les paramètres sont décrits ci-dessous :

path : chemin de stockage et nom du fichier.
pt_spc : vous devez spécifier la partition de niveau le plus bas. Le format est partition_col1=col1_value1, partition_col2=col2_value1....

Effectuer des opérations sur les objets des schémas personnalisés (s_1 et s_2), y compris les opérations inter-schémas.

use projectA;
set odps.namespace.schema=true;-- If this is set at the tenant level, you do not need to specify it here.

-- Operate on table t_c under s_1
use schema s_1;
create table t_c(c1 string,c2 bigint);
INSERT OVERWRITE TABLE t_c VALUES ('a',1),('b',2),('c',3);
select * from t_c;
show tables;
drop table t_c;

tunnel upload <path> t_c[/<pt_spc>];
tunnel download t_c[/pt_spc] <path>;

-- Operate on table t_d under s_2
create table s_2.t_d(c1 string,c2 bigint);
insert into/overwrite table s_2.t_d values ('a',1),('b',2),('c',3);
select * from s_2.t_d;
show tables in s_2;
drop table s_2.t_d;

tunnel upload <path> s_2.t_d[/<pt_spc>];
tunnel download s_2.t_d[/pt_spc] <path>;

-- Operate on resource res_b.jar under s_1
use schema s_1;
add jar <path>/res_b.jar  ;
desc resource res_b.jar;
list resources;
get resource res_b.jar D:\;
drop resource res_b.jar;

-- Operate on resource res_c.jar under s_2
add jar xxx ;-- The add resource command can only be run in the current schema or project. It cannot be run across schemas or projects. Therefore, you must switch to schema s_2 for normal operations.
-- For cross-project or cross-schema operations, use a colon (:) to separate resource levels.
desc resource s_2:res_c.jar;
list resources in s_2;
get resource s_2:res_c.jar D:\;
drop resource s_2:res_c.jar;

-- Operate on function fun_b under s_1
 use schema s_1;
 create function fun_b as 'xx' using 'res_b.jar'
 desc function fun_b;
 list functions;
 drop function fun_b;

 -- Operate on function fun_c under s_2
 create function s_2.fun_c as 'xx' using 's_2/resources/res_c.jar'
 drop function s_2.fun_c;
 desc function s_2.fun_c;
 list functions in s_2;
 drop function s_2.fun_c;

Exemple 2 : Effectuer des opérations inter-projets (effectuer des opérations sur les objets de ProjectB depuis ProjectA).

use projectA;
set odps.namespace.schema=true;  -- If this is set at the tenant level, you do not need to specify it here.

-- Operate on table t_f in schema s_3 under projectB
create table projectB.s_3.t_f(c1 string,c2 bigint);
INSERT OVERWRITE TABLE projectB.s_3.t_f VALUES ('a',1),('b',2),('c',3);
select * from projectB.s_3.t_f;
show tables in projectB.s_3;
desc projectB.s_3.t_f;
drop table projectB.s_3.t_f;

tunnel upload <path> projectB.s_3.t_f[/<pt_spc>];
tunnel download projectB.s_3.t_f[/pt_spc] <path>;

-- Operate on resource res_f.jar in schema s_3 under projectB
add jar xxx ;-- The add resource command can only be run in the current schema or project. It cannot be run across schemas or projects. Therefore, you must switch to projectB and use schema s_3 for normal operations.
-- For cross-project and cross-schema operations, use a colon (:) to separate resource levels.
desc resource projectB:s_3:res_f.jar;
list resources in projectB.s_3;
get resource projectB:s_3:res_f.jar D:\;
drop resource projectB:s_3:res_f.jar;

-- Operate on function fun_f in schema s_3 under projectB
 create function projectB.s_3.fun_f as 'xx' using 'projectB/schemas/s_3/resources/res_f.jar'
 desc function projectB.s_3.fun_f;
 list functions in projectB.s_3;
 drop function projectB.s_3.fun_f;

Autorisations

Accorder des autorisations sur les objets de schéma.

Les autorisations pour les opérations sur les objets de schéma (CreateTable, CreateResource, CreateFunction) sont accordées au niveau du projet. Si vous disposez de ces autorisations sur un projet, elles s'appliquent à tous les schémas de ce projet. Le contrôle d'accès au niveau du schéma sera disponible dans une version future.
Remarque
- Le propriétaire du schéma dispose par défaut de toutes les autorisations d'accès et de contrôle d'accès pour le schéma et les ressources qu'il contient.
- Si vous disposez des autorisations CreateTable, CreateResource et CreateFunction sur un projet, vous héritez automatiquement des autorisations correspondantes pour les schémas de ce projet.

Autorisations sur les objets de ressource dans un schéma.

Lorsque vous accordez des autorisations sur un objet de ressource dans un schéma, spécifiez le nom complet de l'objet (project.schema.table). Pour obtenir la liste des autorisations au niveau des objets, consultez la rubrique Autorisations MaxCompute. Vous pouvez également accorder des autorisations dans la console de gestion. Pour plus d'informations, consultez la rubrique Gérer les autorisations des utilisateurs à l'aide de la console.

-- Grant a role permissions on all tables in a schema.
GRANT schemaObjectPrivileges ON TABLE <project_name>.<schema_name>.* TO role {rolename};
-- Revoke from a role permissions on all tables in a schema.
REVOKE schemaObjectPrivileges ON TABLE <project_name>.<schema_name>.* FROM role {rolename};
-- Grant a role or user permissions on a specific table in a schema.
GRANT schemaObjectPrivileges ON TABLE <project_name>.<schema_name>.<tablename> TO {role|user} {rolename | USER name};-- Grant a role or user permissions on a specific table in a schema.
-- Revoke from a role or user permissions on a specific table in a schema.
REVOKE schemaObjectPrivileges ON TABLE <project_name>.<schema_name>.<tablename> FROM {role|user} {rolename | USER name};
-- View permissions on a table.
SHOW GRANTS ON TABLE <project_name>.<schema_name>.<tablename>;

Remarque

Pour garantir la sécurité des données, la syntaxe GRANT schemaObjectPrivileges ON TABLE <project_name>.<schema_name>.xxx* TO role {rolename}; n'est pas prise en charge.