Zarządzaj eksportami

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

• Utwórz eksporty – wyślij do Vault żądanie, które znajdzie wiadomości lub pliki, które pasują do zapytania i wyeksportują je do Google Cloud.

  Uwaga: w organizacji nie można przeprowadzać więcej niż 20 eksportów w toku. Aby poprawić wydajność, podziel duże eksporty na mniejsze zbiory. Na przykład możesz podzielić eksport według miesięcy zamiast eksportować wszystko naraz. Innym przykładem jest uwzględnienie mniejszej liczby elementów (np. użytkowników oraz specjalnych jednostek, takich jak grupy czy pokój czatu) w każdym eksporcie.

  Przykłady:

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

• Wyświetl listę eksportów – pobierz stan wszystkich powiązanych eksportów. z daną sprawą.

• Pobierz eksporty – pobierz informacje o eksporcie.

• Pobieranie eksportów – pobieranie wyeksportowanych danych z Google Cloud.

• Usuwanie eksportów – usuwa eksporty ze sprawy, jeśli są już nie są potrzebne.

Zanim zaczniesz

Aby skonfigurować wymagane biblioteki i uwierzytelnianie, zapoznaj się z krótkim wprowadzeniem do swojego języka programowania.

Aby można było korzystać z zasobów Vault, konto musi mieć wymagane uprawnienia i dostęp do sprawa. Aby można było uzyskać dostęp do sprawy, właściciel konta musi ją utworzyć, a także mieć udostępnione im sprawę lub uprawnienie Wyświetlanie wszystkich spraw.

Tworzenie eksportu w Gmailu

Z przykładu poniżej dowiesz się, jak utworzyć eksport w Gmailu. Ta prośba o eksport wszystkie wiadomości z Gmaila i klasycznej wersji Hangouts, które spełniają te kryteria:

• wiadomości należące do kont email1 i email2.
• wyklucza wersje robocze wiadomości.
• wiadomości wysłane do [email protected].

Wskazówka: w tych przykładach używany jest klasyczny system eksportowania Gmaila. Aby wyeksportować dane za pomocą nowy system eksportu, w MailExportOptions, ustaw wartość 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

Poniższy przykład pokazuje, jak utworzyć eksport z Dysku. Ta prośba o eksport wszystkie pliki, w tym te na dyskach współdzielonych, które spełniają te kryteria:

• należy do określonej jednostki organizacyjnej (uzyskanej za pomocą pakietu Admin SDK).

• zostało utworzone między określonym times.

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

Poniższy przykład pokazuje, jak utworzyć eksport z Meet. Eksport tej prośby pliki powiązane z kontami w określonej jednostce organizacyjnej, które mają nazwa pliku, która jest zgodna ze wzorcem dla nagrań z 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

Poniższy przykład pokazuje, 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świetlenie listy eksportów

Przykład poniżej 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()

Uzyskiwanie informacji o eksporcie

Z przykładu poniżej dowiesz się, jak uzyskać informacje o konkretnym eksporcie. Uwaga: aby pobrać wyeksportowane pliki i wiadomości, użyj interfejsów Cloud APIs (w następnym kroku ).

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 eksportu z Google Cloud

Przykład poniżej pokazuje, jak pobrać wszystkie ukończone eksporty związane z daną sprawą. od Google Cloud. To żądanie używa interfejsów Vault i Cloud API.

Uwaga: aby pobrać eksport, konto musi mieć Zarządzanie eksportowaniem oraz ze swoją 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

Poniższy przykład pokazuje, 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 dotyczące poszczególnych aplikacji, w tym o limitach wyszukiwania, znajdziesz w artykule Wprowadzenie do wyszukiwania i eksportowania przy użyciu Vault.