Pubblicazione offline

La pubblicazione offline consente a un client, dopo aver effettuato una connessione iniziale al servizio Rights Management, di generare licenze di pubblicazione per il contenuto appena protetto senza effettuare una chiamata al servizio. Ciò è utile per le applicazioni che devono funzionare in modalità offline o che vogliono evitare di effettuare chiamate al servizio.

Requisiti

La funzionalità di pubblicazione offline presenta i requisiti seguenti:

  • Versione supportata di MIP SDK.
  • Utente concesso in licenza per Microsoft Purview Information Protection. Requisiti di licenza
  • Connettività Internet per l'applicazione per inizializzare e memorizzare nella cache i dati offline.

Non supportato

Gli elementi seguenti non sono supportati come parte della funzionalità di pubblicazione offline:

  • Active Directory Rights Management Services (AD RMS) non è supportato.
  • Double Key Encryption (DKE): la funzionalità DKE deve effettuare una chiamata al servizio per recuperare la chiave pubblica al momento della pubblicazione.

Uso della pubblicazione offline con Protection SDK

La pubblicazione offline richiede tre passaggi per consentire all'applicazione di pubblicare senza chiamare il servizio:

  1. Abilitare l'impostazione di pubblicazione offline nelle impostazioni del profilo (per l'SDK applicabile).
  2. Impostare la frequenza di aggiornamento del modello. Questa API imposta il periodo di validità per i modelli memorizzati nella cache.
  3. Chiamare le API di recupero del modello per popolare la cache (GetTemplatesAsync() o GetTemplates()).

Uso della pubblicazione offline con File SDK

File SDK usa la pubblicazione offline per impostazione predefinita e non richiede alcuna configurazione o installazione aggiuntiva.

Comportamento della cache

Un'applicazione non contatterà il servizio per ottenere i modelli finché il periodo di aggiornamento non è scaduto oppure fino a quando non vengono chiamati GetTemplatesAsync() o GetTemplates(). Se l'applicazione è offline e la cache è scaduta, la pubblicazione avrà esito negativo. L'intervallo di aggiornamento dovrebbe raggiungere un equilibrio tra l'utilizzo offline per gli utenti finali e garantire che i modelli siano aggiornati. Per la maggior parte delle applicazioni, 24 ore o meno, è ideale.

Esempi

I frammenti di codice seguenti sono tratti da queste applicazioni di esempio:

Dopo aver completato i passaggi seguenti, la creazione di una licenza di pubblicazione verrà eseguita senza effettuare una chiamata al servizio se la cache dei modelli non è scaduta.

Esempio di C++

Configurare le impostazioni di ProtectionProfile (C++)

// Initialize ProtectionProfileSettings using MipContext
ProtectionProfile::Settings profileSettings(mMipContext,
    mip::CacheStorageType::OnDiskEncrypted,
    ::make_shared<sample::consent::ConsentDelegateImpl>(),
    std::make_shared<ProtectionProfileObserverImpl>()
);

// Enable Offline Publishing
profileSettings.SetOfflinePublishing(true);

Impostare il periodo di aggiornamento del modello (C++)

// Set the template refresh interval
engineSettings.SetTemplateRefreshArgs(std::chrono::hours(24));

Recuperare i modelli per inizializzare la cache (C++)

auto loadPromise = std::make_shared<std::promise<vector<shared_ptr<mip::TemplateDescriptor>>>>();
std::future<vector<shared_ptr<mip::TemplateDescriptor>>> loadFuture = loadPromise->get_future();
mEngine->GetTemplatesAsync(engineObserver, loadPromise);
auto templates = loadFuture.get();

Esempio .NET

Configurare ProtectionProfileSettings (.NET)

// Initialize ProtectionProfileSettings
var profileSettings = new ProtectionProfileSettings(mipContext, 
                CacheStorageType.OnDisk, 
                new ConsentDelegateImplementation());

// Enable Offline Publishing
profileSettings.OfflinePublishing = true;

Impostare il periodo di aggiornamento del modello (.NET)

// Initialize ProtectionEngineSettings
var engineSettings = new ProtectionEngineSettings(identity.Email, authDelegate, "", "")
{
    Identity = identity
};

// Set the template refresh interval
engineSettings.TemplateRefreshRate = new TimeSpan(24, 0, 0);

var engine = profile.AddEngine(engineSettings);

Recuperare i modelli per inizializzare la cache (.NET)

List<TemplateDescriptor> templates = engine.GetTemplates();

Esempio java

Configurare ProtectionProfileSettings (Java)

ProtectionProfileSettings profileSettings = new ProtectionProfileSettings();
profileSettings.setMipContext(mipContext);
profileSettings.setCacheStorageType(CacheStorageType.ON_DISK);
profileSettings.setConsentDelegate(new ConsentDelegateImplementation());

// Enable Offline Publishing
profileSettings.setOfflinePublishing(true);

Impostare il periodo di aggiornamento del modello (Java)

ProtectionEngineSettings engineSettings = new ProtectionEngineSettings(identity.getEmail(), authDelegate, "", "");
engineSettings.setIdentity(identity);

// Set the template refresh interval in hours
engineSettings.setTemplateRefreshRate(Duration.ofHours(24));

Recuperare i modelli per inizializzare la cache (Java)

List<TemplateDescriptor> templates = engine.getTemplates();
  • Last updated on