Communication inter-applications¶

Communication inter-applications : Vue d’ensemble¶

La communication inter-applications (IAC) permet à une Snowflake Native App de fournir des fonctionnalités supplémentaires à d’autres Snowflake Native Apps dans le même compte de consommateur en fournissant un accès à des fonctions et à des procédures que d’autres applications peuvent appeler.

Par exemple, une Snowflake Native App qui résout les IDs client peut aider d’autres Snowflake Native Apps à améliorer les données client en joignant des ensembles de données provenant de différents fournisseurs.

La IAC fournit l’infrastructure pour que deux applications indépendantes, ou plus, communiquent entre elles, tout en respectant leurs besoins en matière de gestion et de sécurité. Les développeurs d’applications activent la IAC pour leur application en procédant comme suit :

• Création d’interfaces

• Utilisation des rôles d’application pour contrôler l’accès aux interfaces.

• Choix d’une interaction synchrone ou asynchrone. L’interaction synchrone utilise des procédures stockées ou des fonctions que d’autres applications peuvent appeler directement, tandis que l’interaction asynchrone donne accès aux résultats des requêtes qui sont stockés dans des tables ou des vues, que d’autres applications peuvent interroger pour vérifier les résultats.

Terminologie¶

La IAC utilise les termes suivants :

Client

L’application qui initie la demande de connexion et appelle les fonctions et procédures de l’application serveur.

Serveur

L’application qui donne accès à ses fonctions et procédures à l’aide de rôles d’application.

Consommateur

L’utilisateur qui installe les applications client et serveur.

Configuration d’application

Un objet SQL que l’application cliente utilise pour demander le nom de l’application serveur. IAC utilise une configuration d’application de type APPLICATION_NAME pour stocker le nom de l’application serveur.

Spécification d’application

Un objet SQL que l’application cliente crée pour demander une connexion à l’application serveur. La IAC utilise une spécification d’application de type CONNECTION. Pour obtenir des informations sur les spécifications d’application, consultez Vue d’ensemble des spécifications d’application.

Workflow pour la communication inter-applications¶

L’établissement et l’utilisation d’une connexion impliquent un processus de négociation entre l’application cliente et l’application serveur.

1. Obtenir les noms des rôles de l’application auprès du fournisseur de l’application serveur : Le fournisseur d’application cliente se coordonne avec le fournisseur d’application serveur en dehors de Snowflake pour déterminer les rôles d’application serveur à demander dans la spécification de connexion.

2. Identifier l’application cible : L’application cliente crée un objet de définition de configuration pour demander le nom de l’application serveur. Le consommateur détecte les demandes entrantes et fournit le nom de l’application serveur à l’application cliente via l’objet de configuration.

3. Demander et approuver une connexion : L’application cliente crée une spécification d’application pour demander une connexion à l’application serveur, et le consommateur approuve la demande de connexion.

4. Communiquer avec l’application serveur : L’application cliente appelle les procédures ou les fonctions de l’application serveur.

ALTER APPLICATION
  SET CONFIGURATION DEFINITION my_server_app_name_configuration
    TYPE = APPLICATION_NAME
    LABEL = 'Server App'
    DESCRIPTION = 'Request for an app that will provide access to server procedures and functions. The server app version must be greater than or equal to 3.2.'
    APPLICATION_ROLES = (my_server_app_role);

SHOW CONFIGURATIONS IN APPLICATION my_server_app_name;

name                             | created_on              | updated_on              | type               | ...
my_server_app_name_configuration | 2026-02-09 10:00:00.000 | 2026-02-09 10:00:00.000 | APPLICATION_NAME   | ...

ALTER APPLICATION my_client_app_name
  SET CONFIGURATION my_server_app_name_configuration
  VALUE = MY_SERVER_APP_NAME;

ALTER APPLICATION SET SPECIFICATION my_server_app_name_connection_specification
  TYPE = CONNECTION
  LABEL = 'Server App'
  DESCRIPTION = 'Request for an app that will provide access to server procedures and functions. The server app version must be greater than or equal to 3.2.'
  SERVER_APPLICATION = MY_SERVER_APP_NAME -- server name obtained from Step 1
  SERVER_APPLICATION_ROLES = (my_server_app_role);

ALTER APPLICATION my_server_app_name
  APPROVE SPECIFICATION my_server_app_name_connection_specification
  SEQUENCE_NUMBER = 1;

SHOW APPROVED SPECIFICATIONS ->>
  SELECT PARSE_JSON("definition"):"SERVER_APPLICATION"::STRING
  FROM $1
  WHERE "name" = 'MY_SERVER_APP_NAME_CONNECTION_SPECIFICATION';

session.call("server_app_name.customer_schema.get_customer_data", customer_id);

session.call("server_app_name.customer_schema.request_customer_data_async", customer_id);

session.call("server_app_name.customer_schema.check_customer_data_requests_async", customer_id);

Gestion des connexions¶

Pour voir les connexions existantes dans Snowsight, procédez comme suit :

1. Connectez-vous à Snowsight.

2. Dans le menu de navigation, sélectionnez Catalog » Apps.

3. Sélectionnez l’application. Toutes les connexions de l’application sont indiquées dans une section intitulée Configurations. Sous cette section se trouve une sous-section intitulée Application connections.

4. Pour modifier une connexion, cliquez sur l’icône en forme de crayon de la connexion. Vous pouvez modifier les éléments suivants :

   • Quelle application est connectée à l’application

   • L’état d’approbation de la connexion

5. Pour voir l’application connectée, cliquez sur le bouton View app.

6. Pour modifier les paramètres de sécurité de la connexion, cliquez sur l’icône en forme d’engrenage.

Remarques relatives à la sécurité¶

Lors de l’approbation d’une demande de spécification, les consommateurs doivent être conscients que l’octroi d’un accès à une application serveur à une application cliente peut augmenter les privilèges dont dispose l’application cliente. Par exemple, si une application serveur dispose d’un accès externe, l’application cliente peut obtenir un accès indirect à Internet ou à d’autres ressources externes via l’application serveur. Si l’application serveur est une application cliente d’une autre application serveur, l’application cliente peut être en mesure d’accéder aux ressources de l’autre application serveur via la première application serveur.

Les consommateurs doivent inspecter les capacités et les privilèges de l’application serveur avant d’approuver une connexion. Utilisez un rôle d’administrateur (par exemple, ACCOUNTADMIN) pour inspecter les capacités du serveur. L’inspection du serveur à l’aide d’un rôle disposant de privilèges réduits ne permettra pas de mettre en évidence l’ensemble des capacités et des privilèges du serveur. Les utilisateurs doivent savoir que le code de l’application serveur ne leur est pas accessible et que les autorisations et capacités de cette application peuvent être modifiées après que l’utilisateur a approuvé la connexion.

Les commandes SQL permettant d’inspecter les capacités et les privilèges de l’application serveur comprennent, sans s’y limiter, les suivantes :

• SHOW GRANTS TO APPLICATION : Cette commande répertorie les autorisations sur l’application cliente qui ont été accordées à l’application serveur.

• SHOW PRIVILEGES IN APPLICATION : Cette commande répertorie les privilèges potentiels au niveau du compte qui pourraient être accordés à l’application cliente.

• SHOW REFERENCES IN APPLICATION : Cette commande répertorie les références que l’application cliente pourrait potentiellement utiliser sans utiliser d’attributions.

• SHOW SPECIFICATIONS IN APPLICATION : Cette commande répertorie les spécifications d’application que le consommateur a approuvées, y compris les intégrations d’accès externes (EAIs), les intégrations de sécurité, les partages, les annonces et les connexions.

Référence SQL¶

Les commandes SQL suivantes sont utilisées pour gérer la communication inter-applications.

• ALTER APPLICATION SET SPECIFICATION : Crée une spécification d’application que l’application serveur utilise pour accorder l’accès à ses fonctions et procédures à l’application cliente.

• ALTER APPLICATION DROP SPECIFICATION : Supprime une spécification d’application.

• ALTER APPLICATION … { APPROVE | DECLINE} SPECIFICATION : Approuve ou refuse une demande de spécification d’application.

• SHOW SPECIFICATIONS : Répertorie toutes les spécifications d’application dans une application.

• DESCRIBE SPECIFICATION : Décrit les spécifications d’application pour une application.

• ALTER APPLICATION SET CONFIGURATION DEFINITION : Crée ou met à jour une configuration d’application (une paire clé-valeur) qui demande le nom d’une autre application au consommateur.

• ALTER APPLICATION DROP CONFIGURATION DEFINITION : Supprime une configuration d’application.

• ALTER APPLICATION SET CONFIGURATION VALUE : Définit une valeur dans une configuration d’application.

• ALTER APPLICATION UNSET CONFIGURATION : Annule la valeur définie dans la configuration d’application spécifiée.

• SHOW CONFIGURATIONS : Répertorie toutes les configurations d’application dans une application.

• DESCRIBE CONFIGURATION : Décrit les détails d’une configuration d’application.

• IS_CONFIGURATION_SET (fonction SYS_CONTEXT) : Indique si la configuration possède ou non une valeur définie.

• GET_CONFIGURATION_VALUE (fonction SYS_CONTEXT) : Renvoie la valeur actuelle de la configuration.

• SHOW GRANTS TO APPLICATION : Répertorie tous les privilèges et rôles de base de données/d’application accordés à l’application spécifiée.

• SHOW GRANTS TO APPLICATION ROLE : Répertorie toutes les autorisations dont dispose le rôle d’application.

• SHOW GRANTS OF APPLICATION ROLE : Répertorie tous les rôles et toutes les applications auxquels le rôle d’application spécifié est accordé.

Rappels¶

Le Snowflake Native App Framework fournit des rappels de cycle de vie pour aider à gérer le workflow de communication inter-applications. Ces rappels permettent à une application de répondre aux modifications des configurations, des connexions et des spécifications. Pour utiliser les rappels, enregistrez-les dans la section lifecycle_callbacks du fichier manifeste de l’application.

Pour des informations générales sur les rappels, voir Rappels.

Exemples¶

Les exemples suivants montrent comment configurer une application pour utiliser la communication inter-applications.

• Exemple : Script d’installation et fichiers manifestes

• Exemple : Communication asynchrone entre les applications

CREATE OR ALTER VERSIONED SCHEMA app_schema;

-- create a callback that creates the connection request before the config value of the server name is saved
CREATE OR REPLACE PROCEDURE app_schema.before_config_change_callback(config_name STRING, config_value STRING)
RETURNS STRING
LANGUAGE SQL
AS
$$
DECLARE
    spec_name VARCHAR;
    existing_target VARCHAR;
BEGIN
    IF (config_value IS NOT NULL AND config_name = 'MY_SERVER_APP_NAME_CONFIGURATION') THEN
        SHOW SPECIFICATIONS;
        SELECT PARSE_JSON("definition"):SERVER_APPLICATION::STRING
            INTO existing_target
            FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()));

        IF(existing_target IS NOT NULL AND UPPER(existing_target) != UPPER(config_value)) THEN
            EXECUTE IMMEDIATE 'ALTER APPLICATION DROP SPECIFICATION CONNECTION_' || UPPER(existing_target);
        END IF;

        spec_name := 'CONNECTION_' || UPPER(config_value);
        EXECUTE IMMEDIATE
        'ALTER APPLICATION SET SPECIFICATION ' || spec_name || '
            TYPE = CONNECTION
            LABEL = ''Server App''
            DESCRIPTION = ''Request for an app that will provide access to server procedures and functions. The server app version must be greater than or equal to 3.2.''
            SERVER_APPLICATION = ' || config_value || '
            SERVER_APPLICATION_ROLES = (my_server_app_role)';
    END IF;
RETURN 'success';
END;
$$;

CREATE APPLICATION ROLE IF NOT EXISTS client_app_user;
GRANT USAGE ON SCHEMA app_schema TO APPLICATION ROLE client_app_user;
ALTER APPLICATION SET CONFIGURATION DEFINITION my_server_app_name_configuration
    TYPE = APPLICATION_NAME
    LABEL = 'Server App'
    DESCRIPTION = 'Request for an application that will provide access to server procedures and functions. The server app version must be greater than or equal to 3.2'
    APPLICATION_ROLES = (client_app_user);

manifest_version: 2

artifacts:
  setup_script: setup.sql

lifecycle_callbacks:
    before_configuration_change: app_schema.before_config_change_callback

CREATE TABLE IF NOT EXISTS app_schema.processing_queue (
  request_id NUMBER AUTOINCREMENT,
  operation STRING,
  input STRING,
  status STRING DEFAULT 'PENDING',
  response STRING DEFAULT ''
);

CREATE OR REPLACE PROCEDURE app_schema.submit_request(operation STRING, input STRING)
RETURNS STRING
LANGUAGE SQL
EXECUTE AS OWNER
AS
$$
BEGIN
    INSERT INTO app_schema.processing_queue (operation, input) VALUES (:operation, :input);
    RETURN 'Request submitted successfully';
END;
$$;

CREATE OR REPLACE PROCEDURE app_schema.process_requests()
RETURNS STRING
LANGUAGE SQL
EXECUTE AS OWNER
AS
$$
DECLARE
    -- Cursor to find all PENDING requests
    c1 CURSOR FOR SELECT * FROM app_schema.processing_queue WHERE status = 'PENDING';
    result STRING;
BEGIN
    FOR request IN c1 DO

        IF (request.operation = 'OPERATION_X') THEN
            -- assuming there is a UDF func_x(input) to perform operation_x
            result := (SELECT func_x(:request.input));
        END IF;

        -- update the processing queue with the result
        LET stmt STRING :=
            'UPDATE app_schema.processing_queue SET status = 'DONE', response = ' ||
            result ||
            ' WHERE request_id = ' ||
            request.request_id;
        EXECUTE IMMEDIATE (:stmt);

    END FOR;

    RETURN 'Processed pending requests.';
END;
$$;

CREATE OR REPLACE PROCEDURE app_schema.fetch_response(operation STRING, input STRING)
RETURNS STRING
LANGUAGE SQL
EXECUTE AS OWNER
AS
$$
BEGIN
    LET res STRING := (SELECT response FROM app_schema.processing_queue WHERE operation = :operation AND input = :input);
    RETURN res;
END;
$$;

CREATE APPLICATION ROLE IF NOT EXISTS my_server_app_role;
GRANT USAGE ON SCHEMA app_schema TO APPLICATION ROLE my_server_app_role;
GRANT USAGE ON PROCEDURE app_schema.submit_request(string, string) TO APPLICATION ROLE my_server_app_role;
GRANT USAGE ON PROCEDURE app_schema.process_requests() TO APPLICATION ROLE my_server_app_role;
GRANT USAGE ON PROCEDURE app_schema.fetch_response(string, string) TO APPLICATION ROLE my_server_app_role;