Zarządzaj eksportami

Interfejs Vault API umożliwia zarządzanie eksportami z Vault. Możesz:

• Tworzenie eksportów – wysyłaj do Vault żądanie, które wyszukuje wiadomości lub pliki pasujące do Twojego zapytania i eksportuje je do Google Cloud.

  Uwaga: w organizacji nie można przeprowadzać więcej niż 20 eksportów naraz. Aby zwiększyć wydajność, podziel duże pliki eksportu na mniejsze zestawy. Możesz na przykład podzielić eksport według miesięcy zamiast eksportować wszystko naraz. Innym przykładem jest uwzględnianie w każdym eksporcie mniejszej liczby elementów (takich jak użytkownicy i elementy specjalne, np. grupy czy pokoje czatu).

  Przykłady:

  • Wiadomości z Gmaila i klasycznej wersji Hangouts
  • Elementy na Dysku
  • nagrania z Meet,
  • Eksportowanie z zapisanego zapytania

• Lista eksportów – wyświetlanie stanu wszystkich eksportów powiązanych ze sprawą.

• Pobierz eksporty – pobierz informacje o eksporcie.

• Pobierz eksporty – pobierz eksport z Google Cloud.

• Usuwanie eksportów – usuwanie eksportów z przypadku, gdy nie są już potrzebne.

Zanim zaczniesz

Aby skonfigurować wymagane biblioteki i uwierzytelnianie, skorzystaj z szybkiego samouczka dla swojego języka programowania.

Aby pracować z zasobami Vault, konto musi mieć wymagane uprawnienia Vault i dostęp do sprawy. Aby uzyskać dostęp do sprawy, konto musi być jej twórcą, sprawa musi być udostępniona temu kontu lub konto musi mieć uprawnienie Wyświetlanie wszystkich spraw.

Tworzenie pliku eksportu z Gmaila

Z przykładu poniżej dowiesz się, jak utworzyć eksport z Gmaila. To żądanie eksportuje wszystkie wiadomości z Gmaila i klasycznej wersji Hangouts, które spełniają te kryteria:

• wiadomości należących do kont email1 i email2.
• nie obejmuje wersji roboczych wiadomości.
• wiadomości wysłanych do [email protected].

Wskazówka: te przykłady używają klasycznego systemu eksportu Gmaila. Aby wyeksportować dane za pomocą nowego systemu eksportu, w MailExportOptions ustaw wartość parametru useNewExport na prawda.

public Export createMailAccountHeldDataExports(Vault client, String matterId) {
  AccountInfo emailsToSearch = new AccountInfo().setEmails(ImmutableList.of("email1", "email2"));
  MailOptions mailQueryOptions = new MailOptions().setExportFormat("PST");
  String queryTerms = "to:[email protected]";
  Query mailQuery =
      new Query()
          .setCorpus("MAIL")
          .setDataScope("HELD_DATA")
          .setSearchMethod("ACCOUNT")
          .setAccountInfo(emailsToSearch)
          .setTerms(queryTerms)
          .setMailOptions(mailQueryOptions);
  MailExportOptions mailExportOptions =
      new MailExportOptions()
          .setExportFormat("MBOX")
          .showConfidentialModeContent(true);
  Export wantedExport =
      new Export()
          .setMatterId(matterId)
          .setName("My first mail accounts export")
          .setQuery(mailQuery)
          .setExportOptions(new ExportOptions().setMailOptions(mailExportOptions));
  return client.matters().exports().create(matter, wantedExport).execute();
}

def create_mail_account_held_data_export(service, matter_id):
  emails_to_search = ['email1', 'email2']
  mail_query_options = {'excludeDrafts': True}
  query_terms = 'to:[email protected]'
  mail_query = {
      'corpus': 'MAIL',
      'dataScope': 'HELD_DATA',
      'searchMethod': 'ACCOUNT',
      'accountInfo': {
          'emails': emails_to_search
      },
      'terms': query_terms,
      'mailOptions': mail_query_options,
  }
  mail_export_options = {
      'exportFormat': 'MBOX',
      'showConfidentialModeContent': True
      }
  wanted_export = {
      'name': 'My first mail accounts export',
      'query': mail_query,
      'exportOptions': {
          'mailOptions': mail_export_options
  }
}
return service.matters().exports().create(
  matterId=matter_id, body=wanted_export).execute()

Tworzenie eksportu z Dysku

W tym przykładzie pokazujemy, jak utworzyć eksport z Dysku. To żądanie eksportuje wszystkie pliki, w tym te na dyskach współdzielonych, które spełniają te kryteria:

• należeć do określonej jednostki organizacyjnej (pozyskanej za pomocą pakietu Admin SDK).

• zostały utworzone w określonym zakresie czasu.

public Export createDriveOuAllDataExport(Vault client, String matterId) {
  OrgUnitInfo ouToSearch = new OrgUnitInfo().setOrgUnitId("ou id retrieved from admin sdk");
  DriveOptions driveQueryOptions = new DriveOptions().setIncludeSharedDrives(true);
  Query driveQuery =
      new Query()
          .setCorpus("DRIVE")
          .setDataScope("ALL_DATA")
          .setSearchMethod("ORG_UNIT")
          .setOrgUnitInfo(ouToSearch)
          .setDriveOptions(driveQueryOptions)
          .setStartTime("2017-03-16T00:00:00Z")
          .setEndTime("2017-03-16T00:00:00Z")
          .setTimeZone("Etc/GMT+2");
  DriveExportOptions driveExportOptions = new DriveExportOptions().setIncludeAccessInfo(false);
  Export wantedExport =
      new Export()
          .setName("My first drive ou export")
          .setQuery(driveQuery)
          .setExportOptions(new ExportOptions().setDriveOptions(driveExportOptions));
  return client.matters().exports().create(matter, wantedExport).execute();
}

def create_drive_ou_all_data_export(service, matter_id):
  ou_to_search = 'ou id retrieved from admin sdk'
  drive_query_options = {'includeSharedDrives': True}
  drive_query = {
    'corpus': 'DRIVE',
    'dataScope': 'ALL_DATA',
    'searchMethod': 'ORG_UNIT',
    'orgUnitInfo': {
        'org_unit_id': ou_to_search
    },
    'driveOptions': drive_query_options,
    'startTime': '2017-03-16T00:00:00Z',
    'endTime': '2017-09-23T00:00:00Z',
    'timeZone': 'Etc/GMT+2'
  }
  drive_export_options = {'includeAccessInfo': False}
  wanted_export = {
    'name': 'My first drive ou export',
    'query': drive_query,
    'exportOptions': {
        'driveOptions': drive_export_options
    }
  }
return service.matters().exports().create(
  matterId=matter_id, body=wanted_export).execute()

Tworzenie eksportu z Meet

W tym przykładzie pokazujemy, jak utworzyć eksport z Meet. To żądanie eksportuje pliki powiązane z kontami w określonej jednostce organizacyjnej, które mają nazwę zgodną ze wzorcem dla nagrań w Meet.

def create_meet_export(service, matter_id, ou_to_search, export_name):
  export = {
    'name': export_name,
    'query': {
        'corpus': 'DRIVE',
        'dataScope': 'ALL_DATA',
        'searchMethod': 'ORG_UNIT',
        'terms': 'title:"...-...-... \\(....-..-.. at ..:.. *\\)"',
        'orgUnitInfo': {
            'orgUnitId': 'id:'+ou_to_search
        },
        'driveOptions': {
            'includeTeamDrives': True,
            'includeSharedDrives': True
        },
        'timeZone': 'Etc/GMT',
        'method': 'ORG_UNIT'
    },
    'exportOptions': {
        'driveOptions': {},
        'region': 'ANY'
    },
  }

  return service.matters().exports().create(
    matterId=matter_id, body=export).execute()

Eksportowanie z zapisanego zapytania

Z tego przykładu dowiesz się, jak utworzyć eksport z zapisanego zapytania.

def create_mail_export_from_saved_query(service, matter_id, saved_query_id, export_name):
  export = {
    'name': export_name,
    'exportOptions': {
      'mailOptions': {
        'exportFormat': 'PST',
        'showConfidentialModeContent': True
      },
    'region': 'ANY'
    }
  }

  export['query'] = service.matters().savedQueries().get(
    savedQueryId=saved_query_id, matterId=matter_id).execute()['query']
  return service.matters().exports().create(
    matterId=matter_id, body=export).execute()

Wyświetlanie listy eksportów

Ten przykład pokazuje, jak pobrać listę eksportów powiązanych ze sprawą.

public class exports {
  public ListExportsResponse listExports(Vault client, String matterId) {
    return client.matters().exports().list(matterId).execute();
}

def list_exports(service, matter_id):
 return service.matters().exports().list(matterId=matter_id).execute()

Wyświetlanie informacji o eksporcie

Ten przykład pokazuje, jak uzyskać informacje o konkretnym wyeksportowanym pliku. Uwaga: do pobierania wyeksportowanych plików i wiadomości używasz interfejsów Cloud API (w następnym przykładzie).

public Export getExportById(Vault client, String matterId, String exportId) {
  return client.matters().exports().get(matterId, exportId).execute();
}

def get_export_by_id(service, matter_id, export_id):
  return service.matters().exports().get(
    matterId=matter_id, exportId=export_id).execute()

Pobieranie danych wyeksportowanych z Google Cloud

Z tego przykładu dowiesz się, jak pobrać z Google Cloud wszystkie ukończone pliki eksportu. To żądanie korzysta z interfejsów Vault i Cloud API.

Uwaga: aby pobrać eksport, konto musi mieć uprawnienie Zarządzanie eksportowaniem i udostępnioną sprawę.

def download_exports(service, matter_id):
"""Google Cloud storage service is authenticated by running
`gcloud auth application-default login` and expects a billing enabled project
in ENV variable `GOOGLE_CLOUD_PROJECT` """
gcpClient = storage.Client()
matter_id = os.environ['MATTERID']
  for export in vaultService.matters().exports().list(
      matterId=matter_id).execute()['exports']:
    if 'cloudStorageSink' in export:
      directory = export['name']
      if not os.path.exists(directory):
        os.makedirs(directory)
      print(export['id'])
      for sinkFile in export['cloudStorageSink']['files']:
        filename = '%s/%s' % (directory, sinkFile['objectName'].split('/')[-1])
        objectURI = 'gs://%s/%s' % (sinkFile['bucketName'],
                                    sinkFile['objectName'])
        print('get %s to %s' % (objectURI, filename))
        gcpClient.download_blob_to_file(objectURI, open(filename, 'wb+'))

Usuwanie eksportu

Z tego przykładu dowiesz się, jak usunąć eksport.

public void deleteExportById(Vault client, String matterId, String exportId) {
   client.matters().exports().delete(matterId, exportId).execute();

def delete_export_by_id(service, matter_id, export_id):
  return service.matters().exports().delete(
    matterId=matter_id, exportId=export_id).execute()

Informacje o wyszukiwaniu i eksportowaniu w poszczególnych aplikacjach, w tym limity wyszukiwania, znajdziesz w artykule Wprowadzenie do wyszukiwania i eksportowania.