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:

  • 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. Eksport tej prośby 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 ceo@solarmora.com.

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.

Java

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:ceo@solarmora.com";
  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();
}

Python

def create_mail_account_held_data_export(service, matter_id):
  emails_to_search = ['email1', 'email2']
  mail_query_options = {'excludeDrafts': True}
  query_terms = 'to:ceo@solarmora.com'
  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. Eksport tej prośby wszystkie pliki, w tym te na dyskach współdzielonych, które spełniają te kryteria:

  • należą do określonej jednostki organizacyjnej (uzyskanej za pomocą pakietu Admin SDK).
  • zostało utworzone między określonym times.

Java

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();
}

Python

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 zgodna ze wzorcem dla nagrań z Meet.

Python

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.

Python

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ą.

Java

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

Python

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 ).

Java

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

Python

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ą.

Python

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.

Java

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

Python

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.