Dateien, Ordner & Laufwerke freigeben

Jede Google Drive-Datei, jeder Ordner und jede geteilte Ablage wurde verknüpft permissions erstellen. Jede Ressource steht für die Berechtigung für eine bestimmte type (Nutzer, Gruppe, Domain, alle) und role, z. B. "commenter" oder „Leser“. Zum Beispiel kann eine Datei Berechtigung, die einem bestimmten Nutzer (type=user) Lesezugriff gewährt (role=reader) und eine andere Berechtigung gewährt Mitgliedern einer bestimmten Gruppe (type=group) die Möglichkeit, einer Datei Kommentare hinzuzufügen (role=commenter).

Eine vollständige Liste der Rollen und der jeweils zulässigen Vorgänge finden Sie unter Rollen und Berechtigungen

Szenarien für die Freigabe von Drive-Ressourcen

Es gibt fünf verschiedene Arten von Freigabeszenarien:

  1. Zum Freigeben einer Datei in „Meine Ablage“ benötigt der Nutzer role=writer oder role=owner.

    • Wenn der boolesche Wert writersCanShare für die Datei auf False gesetzt ist, muss der Nutzer role=owner haben.

    • Wenn der Nutzer mit role=writer vorübergehenden Zugriff hat, der durch eine Ablaufdatum und -uhrzeit haben, können sie die Datei nicht freigeben. Weitere Informationen Weitere Informationen finden Sie unter Ablaufdatum zum Begrenzen der Datei festlegen Zugriff.

  2. Um einen Ordner in „Meine Ablage“ freizugeben, muss der Nutzer role=writer oder role=owner.

    • Wenn der boolesche Wert writersCanShare für die Datei auf False festgelegt ist, muss der Nutzer die Berechtigung für role=owner mit mehr Berechtigungen haben.

    • Vorübergehender Zugriff (mit Ablaufdatum und -uhrzeit) ist nicht zulässig für Ordner in „Meine Ablage“ mit role=writer. Weitere Informationen finden Sie unter Legen Sie ein Ablaufdatum fest, um den Dateizugriff einzuschränken.

  3. Um eine Datei in einer geteilten Ablage freizugeben, benötigt der Nutzer role=writer, role=fileOrganizer oder role=organizer.

    • Die Einstellung writersCanShare gilt nicht für Elemente in geteilten Ablagen. Es wird so behandelt, als wäre es immer auf True festgelegt.

  4. Um einen Ordner in einer geteilten Ablage freizugeben, benötigt der Nutzer role=organizer.

    • Wenn die Einschränkung sharingFoldersRequiresOrganizerPermission für eine geteilte Ablage auf False gesetzt ist, können Nutzer mit role=fileOrganizer folgende Aktionen ausführen: Ordner in dieser geteilten Ablage freigeben.

  5. Um die Mitgliedschaft in geteilten Ablagen zu verwalten, muss der Nutzer role=organizer haben. Nur Nutzer und Gruppen können Mitglieder von geteilten Ablagen sein.

Ablaufdatum festlegen, um den Dateizugriff zu beschränken

Wenn Sie mit Personen an einem sensiblen Projekt arbeiten, den Zugriff auf bestimmte Dateien in Google Drive nach einem . Für Dateien in „Meine Ablage“ können Sie folgendes Ablaufdatum festlegen: den Zugriff auf diese Datei einschränken oder entfernen.

So legen Sie das Ablaufdatum fest:

Das Feld expirationTime gibt unter Verwendung von RFC 3339 an, wann die Berechtigung abläuft. Datum-Uhrzeit . Für Ablaufzeiten gelten die folgenden Einschränkungen:

  • Sie können nur für Nutzer- und Gruppenberechtigungen festgelegt werden.
  • Die Zeit muss in der Zukunft liegen.
  • Der Zeitpunkt darf nicht mehr als ein Jahr in der Zukunft liegen.

Weitere Informationen zum Ablaufdatum finden Sie in den folgenden Artikeln:

Berechtigungsverteilung

Berechtigungslisten für einen Ordner werden nach unten weitergegeben und alle untergeordneten Dateien und Ordner übernehmen Berechtigungen vom übergeordneten Element. Wenn Berechtigungen oder die wird die Hierarchie geändert, erfolgt die Weitergabe rekursiv durch alle verschachtelten Ordner. Wenn beispielsweise eine Datei in einem Ordner vorhanden ist und dieser Ordner dann verschoben wird, innerhalb eines anderen Ordners werden die Berechtigungen für den neuen Ordner auf die Datei angewendet. Wenn der neue Ordner dem Nutzer der Datei eine neue Rolle wie „writer“ gewährt, sie ihre alte Rolle überschrieben.

Wenn dagegen eine Datei role=writer aus einem Ordner übernimmt und nach Ordner mit einem „Reader“ festgelegt haben, erbt die Datei role=reader.

Übernommene Berechtigungen können nicht für eine Datei oder einen Ordner in einer geteilten Ablage entfernt werden. Stattdessen müssen diese Berechtigungen für das direkte oder indirekte übergeordnete Element die sie vererbt wurden. Übernommene Berechtigungen können für Elemente entfernt werden unter „Meine Ablage“ oder "Für mich freigegeben".

Umgekehrt können übernommene Berechtigungen für eine Datei oder einen Ordner in "Meine" Drive Wenn eine Datei also role=writer von einem Drive-Ordner haben, können Sie role=reader für die Datei festlegen, um Berechtigungsstufe.

Leistungsspektrum

Die Ressource Permissions muss letztendlich nicht Die Fähigkeit des aktuellen Nutzers bestimmen, Aktionen für eine Datei oder einen Ordner auszuführen. Stattdessen enthält eine Ressource vom Typ Files eine Sammlung von booleschen capabilities-Felder, mit denen angegeben wird, ob eine Aktion die für eine Datei oder einen Ordner durchgeführt wurden. Die Google Drive API legt diese Felder auf der Grundlage Die Berechtigungsressource des aktuellen Nutzers, die mit der Datei oder dem Ordner verknüpft ist.

Wenn sich Alex beispielsweise in Ihrer App anmeldet und eine Datei freigeben möchte, wird auf Berechtigungen für die Datei geprüft. Wenn die Rolle es ihnen erlaubt, eine Datei freizugeben, Die capabilities für die Datei, z. B. canShare, werden ausgefüllt. die zur Rolle passen. Wenn Alex die Datei freigeben möchte, prüft Ihre App die capabilities, um sicherzustellen, dass canShare auf true gesetzt ist.

Ein Beispiel für das Abrufen der Datei capabilities finden Sie unter Nutzer bestätigen Berechtigungen

Berechtigung erstellen

Die folgenden beiden Felder sind beim Erstellen einer Berechtigung erforderlich:

  • type: type gibt den Umfang der Berechtigung an (user, group, domain oder anyone. Eine Berechtigung mit type=user gilt für einen bestimmten Nutzer, während gilt eine Berechtigung mit type=domain für alle Nutzer in einer bestimmten Domain.

  • role: Das Feld role gibt die Vorgänge an, die type ausführen kann. Beispiel: Die Berechtigung mit type=user und role=reader gewährt einem bestimmten Nutzer die Berechtigung auf die Datei oder den Ordner. Oder eine Berechtigung mit type=domain und mit role=commenter können alle Nutzer in der Domain einer Datei Kommentare hinzufügen. Für eine vollständige Liste der Rollen und der jeweils zulässigen Vorgänge finden Sie unter Rollen und Berechtigungen

Wenn Sie eine Berechtigung mit type=user oder type=group erstellen, müssen Sie auch eine emailAddress zum Nutzer oder Gruppe für die Berechtigung zuständig ist.

Wenn Sie eine Berechtigung mit type=domain erstellen, müssen Sie auch eine domain zum Verknüpfen einer bestimmten Domain zur Genehmigung vor.

So erstellen Sie eine Berechtigung:

  1. Methode permissions.create verwenden durch die fileId für die verknüpfte Datei oder den verknüpften Ordner.
  2. Geben Sie im Anfragetext type und role an.
  3. Wenn type=user oder type=group, gib eine emailAddress an. Wenn type=domain, domain angeben.

Beispiel ansehen

Das folgende Codebeispiel zeigt, wie eine Berechtigung erstellt wird. Die Antwort gibt eine Instanz einer Permission-Ressource zurück, einschließlich der zugewiesenen permissionId.

Anfrage

POST https://www.googleapis.com/drive/v3/files/FILE_ID/permissions
{
  "requests": [
    {
        "type": "user",
        "role": "commenter",
        "emailAddress": "alex@altostrat.com"
    }
  ]
}

Antwort

{
    "kind": "drive#permission",
    "id": "PERMISSION_ID",
    "type": "user",
    "role": "commenter"
}

Zielgruppen verwenden

Zielgruppen sind Personengruppen, z. B. Abteilungen oder Teams, für die Nutzer ihre Artikel freigeben können. Sie können Nutzer dazu ermutigen, mit einer spezifischeren oder eingeschränkten Zielgruppe als mit dem gesamten Unternehmen. Mit Zielgruppen können Sie die Sicherheit und den Datenschutz und Nutzern die angemessene Weitergabe von Daten erleichtern. Weitere Informationen erhalten Sie unter Informationen zu Zielen Zielgruppen .

So verwenden Sie Zielgruppen:

  1. Öffnen Sie in der Admin-Konsole das Menü. > Verzeichnis > Zielgruppen.

    „Zielgruppen“ aufrufen

    Für diese Aufgabe müssen Sie mit einem Konto mit Super Admin-Berechtigungen angemeldet sein.

  2. Klicken Sie in der Liste Zielgruppen auf den Namen der Zielgruppe. Bis Informationen zum Erstellen einer Zielgruppe finden Sie unter Zielgruppe erstellen Zielgruppe

  3. Kopieren Sie die eindeutige ID aus der Zielgruppen-URL: https://admin.google.com/ac/targetaudiences/ID.

  4. Erstellen Sie eine Berechtigung mit type=domain und legen Sie das Feld domain auf ID.audience.googledomains.com fest.

Informationen dazu, wie Nutzer mit Zielgruppen interagieren, finden Sie unter Nutzererfahrung für Link Teilen .

Alle Berechtigungen für eine Datei, einen Ordner oder eine geteilte Ablage abrufen

Verwenden Sie die Methode permissions.list, um alle Berechtigungen für eine Datei, einen Ordner oder eine geteilte Ablage abzurufen.

Beispiel ansehen

Das folgende Codebeispiel zeigt, wie Sie alle Berechtigungen abrufen. In der Antwort wird eine Liste von Berechtigungen zurückgegeben.

Anfrage

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissions

Antwort

{
  "kind": "drive#permissionList",
  "permissions": [
    {
      "id": "PERMISSION_ID",
      "type": "user",
      "kind": "drive#permission",
      "role": "commenter"
    }
  ]
}

Nutzerberechtigungen überprüfen

Wenn Ihre App eine Datei öffnet, sollte sie deren Funktionen prüfen und rendern auf der Benutzeroberfläche, um die Berechtigungen des aktuellen Nutzers widerzuspiegeln. Wenn Nutzende beispielsweise hat keine canComment-Berechtigung für die Datei, Kommentierzugriff in der UI deaktiviert werden sollte.

Weitere Informationen zu capabilities finden Sie unter Funktionen. oben.

Rufen Sie zum Prüfen der Funktionen files.get mit fileId und fields, die auf das Feld capabilities festgelegt sind. Für Weitere Informationen zur Rückgabe von Feldern mit dem Parameter fields finden Sie unter Bestimmte Felder für eine Datei zurückgeben.

Beispiel ansehen

Das folgende Codebeispiel zeigt, wie Nutzerberechtigungen überprüft werden. Die Antwort gibt eine Liste der Berechtigungen zurück, die der Nutzer für die Datei hat. Jede Fähigkeit entspricht einer detaillierten Aktion, die ein Nutzer ausführen kann. Einige Felder werden nur für Elemente in geteilten Ablagen ausgefüllt.

Anfrage

GET https://www.googleapis.com/drive/v3/files/FILE_ID?fields=capabilities

Antwort

{
  "capabilities": {
    "canAcceptOwnership": false,
    "canAddChildren": false,
    "canAddMyDriveParent": false,
    "canChangeCopyRequiresWriterPermission": true,
    "canChangeSecurityUpdateEnabled": false,
    "canComment": true,
    "canCopy": true,
    "canDelete": true,
    "canDownload": true,
    "canEdit": true,
    "canListChildren": false,
    "canModifyContent": true,
    "canModifyContentRestriction": true,
    "canModifyLabels": true,
    "canMoveChildrenWithinDrive": false,
    "canMoveItemOutOfDrive": true,
    "canMoveItemWithinDrive": true,
    "canReadLabels": true,
    "canReadRevisions": true,
    "canRemoveChildren": false,
    "canRemoveMyDriveParent": true,
    "canRename": true,
    "canShare": true,
    "canTrash": true,
    "canUntrash": true
  }
}

Quelle der Rolle für Dateien in geteilten Ablagen ermitteln und Ordner

Wenn Sie die Rolle für eine Datei oder einen Ordner ändern möchten, müssen Sie die Quelle der Rolle kennen. Bei geteilten Ablagen kann die Quelle einer Rolle auf der Mitgliedschaft in der geteilten Ablage basieren. Drive, die Rolle für einen Ordner oder eine Datei.

So ermitteln Sie die Quelle der Rolle für eine geteilte Ablage oder für Elemente darin permissions.get mit der fileId, der permissionId und der fields-Parameter, die auf den permissionDetails verwendet. Um die permissionId zu finden, verwenden Sie permissions.list durch fileId. Bis das Feld permissionDetails in der permissions.list-Anfrage abrufen, die fields auf permissions/permissionDetails.

Dieses Feld listet alle übernommenen und direkten Dateiberechtigungen für den Nutzer, Gruppe oder Domain.

Beispiel ansehen

Das folgende Codebeispiel zeigt, wie die Rollenquelle ermittelt wird. Die Antwort gibt den permissionDetails einer Permission-Ressource zurück. Das Feld „inheritedFrom“ enthält die ID des Elements, von dem die Berechtigung übernommen wurde.

Anfrage

GET https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID?fields=permissionDetails&supportsAllDrives=true

Antwort

{
  "permissionDetails": [
    {
      "permissionType": "member",
      "role": "commenter",
      "inheritedFrom": "INHERITED_FROM_ID",
      "inherited": true
    },
    {
      "permissionType": "file",
      "role": "writer",
      "inherited": false
    }
  ]
}

Berechtigungen ändern

Um die Berechtigungen für eine Datei oder einen Ordner zu ändern, können Sie die zugewiesene Rolle ändern:

  1. Rufen Sie permissions.update mit dem permissionId der Berechtigung zur Änderung und der fileId für die verknüpfte Datei, Ordner oder geteilte Ablage. Um die permissionId zu finden, verwenden Sie permissions.list durch fileId.

  2. Identifizieren Sie in der Anfrage die neue role.

Sie können Berechtigungen für einzelne Dateien oder Ordner in einer geteilten Ablage erteilen, wenn der Nutzer oder die Gruppe bereits Mitglied ist. Beispiel: Alex hat role=commenter als Mitglied einer geteilten Ablage. Ihre App kann Alex jedoch erlauben, role=writer für eine Datei in einer geteilten Ablage. Da die neue Rolle in diesem Fall die mehr Berechtigungen hat als die Rolle, die durch ihre Mitgliedschaft gewährt wird. Die Berechtigung wird zur effektiven Rolle für die Datei oder den Ordner.

Beispiel ansehen

Das folgende Codebeispiel zeigt, wie die Berechtigungen für eine Datei oder einen Ordner von „Kommentator“ zu „Autor“ geändert werden. Die Antwort gibt eine Instanz einer Permission-Ressource zurück.

Anfrage

PATCH https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID
{
  "requests": [
    {
        "role": "writer"
    }
  ]
}

Antwort

{
  "kind": "drive#permission",
  "id": "PERMISSION_ID",
  "type": "user",
  "role": "writer"
}

Zugriff auf Dateien oder Ordner widerrufen

Um den Zugriff auf eine Datei oder einen Ordner zu widerrufen, rufen Sie delete durch fileId und den permissionId, um die Berechtigung zu löschen.

Für Elemente in „Meine Ablage“ können Sie eine übernommene Berechtigung. Durch das Löschen einer übernommenen Berechtigung wird der Zugriff auf das Element entzogen und untergeordnete Elemente.

Für Elemente in einer geteilten Ablage können übernommene Berechtigungen nicht widerrufen werden. Aktualisieren oder die Berechtigung für die übergeordnete Datei oder den übergeordneten Ordner widerrufen.

Mit dem Vorgang delete werden auch Berechtigungen gelöscht, die direkt auf einen Datei oder Ordner in der geteilten Ablage.

Beispiel ansehen

Das folgende Codebeispiel zeigt, wie Sie den Zugriff durch Löschen eines permissionId widerrufen. Wenn der Vorgang erfolgreich ist, ist der Antworttext leer. Bestätigen Sie, dass die Berechtigung entfernt wurde. Verwenden Sie dazu permissions.list mit der fileId.

Anfrage

DELETE https://www.googleapis.com/drive/v3/files/FILE_ID/permissions/PERMISSION_ID

Eigentümerschaft für Dateien auf ein anderes Google Workspace-Konto in derselben Organisation übertragen

Eigentümerschaft von Dateien in „Meine Ablage“ kann übertragen werden von ein Google Workspace-Konto mit einem anderen Konto in derselben Organisation. Eine Organisation, die Eigentümer eines freigegebenen dass Drive Eigentümer der darin enthaltenen Dateien ist. Daher werden Übertragungen von Eigentumsrechten nicht unterstützt. für Dateien und Ordner in geteilten Ablagen. Organisatoren einer geteilten Ablage können Elemente verschieben Elemente aus dieser geteilten Ablage und in ihrer eigenen Ablage welche die Eigentumsrechte an sie übertragen.

Um die Eigentümerschaft einer Datei in „Meine Ablage“ zu übertragen, führen Sie einen der Folgendes:

  • Eine Dateiberechtigung erstellen, die einem bestimmten Nutzer gewährt (type=user) Inhaberzugriff (role=owner)

  • Berechtigung einer vorhandenen Datei mit role=owner aktualisieren und übertragen Eigentumsrechte an den angegebenen Nutzer (transferOwnership=true) zu übertragen.

Eigentümerschaft für Dateien von einem Privatnutzerkonto auf ein anderes übertragen

Die Eigentümerschaft von Dateien kann von einem Privatnutzerkonto auf ein anderes übertragen werden. Die Eigentümerschaft an einer Datei wird jedoch nicht auf einen anderen Nutzer übertragen. Verbraucher Konten bis der potenzielle neue Inhaber der Übertragung ausdrücklich zustimmt. Zum Übertragen Dateieigentümerschaft von einem Privatnutzerkonto an ein anderes:

  1. Der aktuelle Inhaber initiiert die Übertragung der Eigentumsrechte, indem er die Dateiberechtigung des potenziellen neuen Eigentümers. Die Berechtigung muss Folgendes enthalten: diese Einstellungen: role=writer, type=user und pendingOwner=true. Wenn die neuer Inhaber erstellt eine Berechtigung für den potenziellen Inhaber, eine E-Mail-Adresse wird eine Benachrichtigung an den potenziellen neuen Eigentümer gesendet, wenn sie aufgefordert werden, die Eigentümerschaft für die Datei zu übernehmen.

  2. Der neue Inhaber akzeptiert die Anfrage zur Übertragung der Eigentumsrechte, indem er Dateiberechtigung. Die Berechtigung muss die folgenden Einstellungen enthalten: role=owner und transferOwnership=true. Wenn der neue Eigentümer ein neue Berechtigung hat, wird eine E-Mail-Benachrichtigung an den vorherigen Eigentümer gesendet gibt an, dass die Inhaberschaft übertragen wurde.

Wenn eine Datei übertragen wird, wird die Rolle des vorherigen Eigentümers auf writer herabgestuft.

<ph type="x-smartling-placeholder">

Mehrere Berechtigungen mit Batchanfragen ändern

Wir empfehlen dringend, Batchanfragen zum Ändern mehrerer Berechtigungen.

Das folgende Beispiel zeigt, wie Sie eine Batch-Berechtigungsänderung mit einer Clientbibliothek.

Java

drive/snippets/drive_v3/src/main/java/ShareFile.java
import com.google.api.client.googleapis.batch.BatchRequest;
import com.google.api.client.googleapis.batch.json.JsonBatchCallback;
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpHeaders;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.Permission;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/* Class to demonstrate use-case of modify permissions. */
public class ShareFile {

  /**
   * Batch permission modification.
   * realFileId file Id.
   * realUser User Id.
   * realDomain Domain of the user ID.
   *
   * @return list of modified permissions if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static List<String> shareFile(String realFileId, String realUser, String realDomain)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
         TODO(developer) - See https://developers.google.com/identity for
         guides on implementing OAuth2 for your application.application*/
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();

    final List<String> ids = new ArrayList<String>();


    JsonBatchCallback<Permission> callback = new JsonBatchCallback<Permission>() {
      @Override
      public void onFailure(GoogleJsonError e,
                            HttpHeaders responseHeaders)
          throws IOException {
        // Handle error
        System.err.println(e.getMessage());
      }

      @Override
      public void onSuccess(Permission permission,
                            HttpHeaders responseHeaders)
          throws IOException {
        System.out.println("Permission ID: " + permission.getId());

        ids.add(permission.getId());

      }
    };
    BatchRequest batch = service.batch();
    Permission userPermission = new Permission()
        .setType("user")
        .setRole("writer");

    userPermission.setEmailAddress(realUser);
    try {
      service.permissions().create(realFileId, userPermission)
          .setFields("id")
          .queue(batch, callback);

      Permission domainPermission = new Permission()
          .setType("domain")
          .setRole("reader");

      domainPermission.setDomain(realDomain);

      service.permissions().create(realFileId, domainPermission)
          .setFields("id")
          .queue(batch, callback);

      batch.execute();

      return ids;
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to modify permission: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/share_file.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def share_file(real_file_id, real_user, real_domain):
  """Batch permission modification.
  Args:
      real_file_id: file Id
      real_user: User ID
      real_domain: Domain of the user ID
  Prints modified permissions

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create drive api client
    service = build("drive", "v3", credentials=creds)
    ids = []
    file_id = real_file_id

    def callback(request_id, response, exception):
      if exception:
        # Handle error
        print(exception)
      else:
        print(f"Request_Id: {request_id}")
        print(f'Permission Id: {response.get("id")}')
        ids.append(response.get("id"))

    # pylint: disable=maybe-no-member
    batch = service.new_batch_http_request(callback=callback)
    user_permission = {
        "type": "user",
        "role": "writer",
        "emailAddress": "user@example.com",
    }
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=user_permission,
            fields="id",
        )
    )
    domain_permission = {
        "type": "domain",
        "role": "reader",
        "domain": "example.com",
    }
    domain_permission["domain"] = real_domain
    batch.add(
        service.permissions().create(
            fileId=file_id,
            body=domain_permission,
            fields="id",
        )
    )
    batch.execute()

  except HttpError as error:
    print(f"An error occurred: {error}")
    ids = None

  return ids


if __name__ == "__main__":
  share_file(
      real_file_id="1dUiRSoAQKkM3a4nTPeNQWgiuau1KdQ_l",
      real_user="gduser1@workspacesamples.dev",
      real_domain="workspacesamples.dev",
  )

Node.js

drive/snippets/drive_v3/file_snippets/share_file.js
/**
 * Batch permission modification
 * @param{string} fileId file ID
 * @param{string} targetUserEmail username
 * @param{string} targetDomainName domain
 * @return{list} permission id
 * */
async function shareFile(fileId, targetUserEmail, targetDomainName) {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const permissionIds = [];

  const permissions = [
    {
      type: 'user',
      role: 'writer',
      emailAddress: targetUserEmail, // 'user@partner.com',
    },
    {
      type: 'domain',
      role: 'writer',
      domain: targetDomainName, // 'example.com',
    },
  ];
  // Note: Client library does not currently support HTTP batch
  // requests. When possible, use batched requests when inserting
  // multiple permissions on the same item. For this sample,
  // permissions are inserted serially.
  for (const permission of permissions) {
    try {
      const result = await service.permissions.create({
        resource: permission,
        fileId: fileId,
        fields: 'id',
      });
      permissionIds.push(result.data.id);
      console.log(`Inserted permission id: ${result.data.id}`);
    } catch (err) {
      // TODO(developer): Handle failed permissions
      console.error(err);
    }
  }
  return permissionIds;
}

PHP

drive/snippets/drive_v3/src/DriveShareFile.php
use Google\Client;
use Google\Service\Drive;
function shareFile()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $realFileId = readline("Enter File Id: ");
        $realUser = readline("Enter user email address: ");
        $realDomain = readline("Enter domain name: ");
        $ids = array();
            $fileId = '1sTWaJ_j7PkjzaBWtNc3IzovK5hQf21FbOw9yLeeLPNQ';
            $fileId = $realFileId;
            $driveService->getClient()->setUseBatch(true);
            try {
                $batch = $driveService->createBatch();

                $userPermission = new Drive\Permission(array(
                    'type' => 'user',
                    'role' => 'writer',
                    'emailAddress' => 'user@example.com'
                ));
                $userPermission['emailAddress'] = $realUser;
                $request = $driveService->permissions->create(
                    $fileId, $userPermission, array('fields' => 'id'));
                $batch->add($request, 'user');
                $domainPermission = new Drive\Permission(array(
                    'type' => 'domain',
                    'role' => 'reader',
                    'domain' => 'example.com'
                ));
                $userPermission['domain'] = $realDomain;
                $request = $driveService->permissions->create(
                    $fileId, $domainPermission, array('fields' => 'id'));
                $batch->add($request, 'domain');
                $results = $batch->execute();

                foreach ($results as $result) {
                    if ($result instanceof Google_Service_Exception) {
                        // Handle error
                        printf($result);
                    } else {
                        printf("Permission ID: %s\n", $result->id);
                        array_push($ids, $result->id);
                    }
                }
            } finally {
                $driveService->getClient()->setUseBatch(false);
            }
            return $ids;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/ShareFile.cs
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data;
using Google.Apis.Requests;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use-case of Drive modify permissions.
    public class ShareFile
    {
        /// <summary>
        /// Batch permission modification.
        /// </summary>
        /// <param name="realFileId">File id.</param>
        /// <param name="realUser">User id.</param>
        /// <param name="realDomain">Domain id.</param>
        /// <returns>list of modified permissions, null otherwise.</returns>
        public static IList<String> DriveShareFile(string realFileId, string realUser, string realDomain)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                var ids = new List<String>();
                var batch = new BatchRequest(service);
                BatchRequest.OnResponse<Permission> callback = delegate(
                    Permission permission,
                    RequestError error,
                    int index,
                    HttpResponseMessage message)
                {
                    if (error != null)
                    {
                        // Handle error
                        Console.WriteLine(error.Message);
                    }
                    else
                    {
                        Console.WriteLine("Permission ID: " + permission.Id);
                    }
                };
                Permission userPermission = new Permission()
                {
                    Type = "user",
                    Role = "writer",
                    EmailAddress = realUser
                };

                var request = service.Permissions.Create(userPermission, realFileId);
                request.Fields = "id";
                batch.Queue(request, callback);

                Permission domainPermission = new Permission()
                {
                    Type = "domain",
                    Role = "reader",
                    Domain = realDomain
                };
                request = service.Permissions.Create(domainPermission, realFileId);
                request.Fields = "id";
                batch.Queue(request, callback);
                var task = batch.ExecuteAsync();
                task.Wait();
                return ids;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}