Dateien, Ordner & Laufwerke freigeben

Jeder Google Drive-Datei, jedem Ordner und jeder geteilten Ablage sind zugehörige Berechtigungsressourcen zugewiesen. Jede Ressource identifiziert die Berechtigung für eine bestimmte type (Nutzer, Gruppe, Domain, jeden) und role, z. B. „Kommentator“ oder „Leser“. Beispielsweise kann eine Datei eine Berechtigung haben, die einem bestimmten Nutzer (type=user) Lesezugriff gewährt (role=reader), während eine andere Berechtigung Mitgliedern einer bestimmten Gruppe (type=group) die Möglichkeit gewährt, 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. Um eine Datei in „Meine Ablage“ freizugeben, muss der Nutzer role=writer oder role=owner haben.

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

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

    • Vorübergehender Zugriff (gesteuert durch Ablaufdatum und -zeit) ist für Ordner in „Meine Ablage“ mit role=writer nicht zulässig. Weitere Informationen finden Sie unter Ablaufdatum zur Einschränkung des Dateizugriffs festlegen.

  3. Um eine Datei in einer geteilten Ablage freizugeben, muss der Nutzer die Berechtigung role=writer, role=fileOrganizer oder role=organizer haben.

    • 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, muss der Nutzer die Berechtigung role=organizer haben.

    • Wenn die Einschränkung sharingFoldersRequiresOrganizerPermission für eine geteilte Ablage auf False festgelegt ist, können Nutzer mit role=fileOrganizer Ordner in dieser geteilten Ablage freigeben.
  5. Um die Mitgliedschaft in geteilten Ablagen verwalten zu können, muss der Nutzer role=organizer haben. Nur Nutzer und Gruppen können Mitglieder von geteilten Ablagen sein.

Ablaufdatum festlegen, um den Dateizugriff einzuschränken

Wenn Sie mit Personen an einem vertraulichen Projekt arbeiten, kann es sinnvoll sein, deren Zugriff auf bestimmte Dateien in Drive nach einer gewissen Zeit einzuschränken. Für Dateien in „Meine Ablage“ können Sie ein Ablaufdatum festlegen, um den Zugriff auf diese Datei einzuschränken oder zu entfernen.

So legen Sie das Ablaufdatum fest:

Das Feld expirationTime gibt unter RFC 3339-Datum/Uhrzeit an, wann die Berechtigung abläuft. 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 angewendet und alle untergeordneten Dateien und Ordner übernehmen die Berechtigungen des übergeordneten Ordners. Immer wenn Berechtigungen oder die Hierarchie geändert werden, erfolgt die Weitergabe rekursiv durch alle verschachtelten Ordner. Wenn beispielsweise eine Datei in einem Ordner vorhanden ist und dieser Ordner dann in einen anderen Ordner verschoben wird, werden die Berechtigungen für den neuen Ordner von der Datei übernommen. Wenn der neue Ordner dem Nutzer der Datei eine neue Rolle zuweist, z. B. "writer", wird die alte Rolle überschrieben.

Umgekehrt übernimmt die Datei jetzt role=reader, wenn eine Datei role=writer von einem Ordner übernimmt und dann in einen anderen Ordner verschoben wird, der eine „Leser“-Rolle hat.

Übernommene Berechtigungen können nicht aus einer Datei oder einem Ordner in einer geteilten Ablage entfernt werden. Stattdessen müssen diese Berechtigungen für das direkte oder indirekte übergeordnete Element angepasst werden, von dem sie übernommen wurden. Übernommene Berechtigungen können aus Elementen in "Meine Ablage" oder "Für mich freigegeben" entfernt werden.

Umgekehrt können übernommene Berechtigungen für eine Datei oder einen Ordner in „Meine Ablage“ überschrieben werden. Wenn eine Datei also role=writer von einem Ordner in „Meine Ablage“ übernimmt, können Sie role=reader für die Datei festlegen, um die Berechtigungsstufe zu verringern.

Leistungsspektrum

Die Ressource Permissions bestimmt nicht letztendlich, ob der aktuelle Nutzer Aktionen für eine Datei oder einen Ordner ausführen kann. Stattdessen enthält eine Ressource vom Typ Files eine Sammlung boolescher capabilities-Felder, die angeben, ob eine Aktion für eine Datei oder einen Ordner ausgeführt werden kann. Die Google Drive API legt diese Felder basierend auf der Berechtigungsressource des aktuellen Nutzers fest, die mit der Datei oder dem Ordner verknüpft ist.

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

Ein Beispiel zum Abrufen der Datei capabilities finden Sie unter Nutzerberechtigungen prüfen.

Berechtigung erstellen

Die folgenden beiden Felder sind für das Erstellen einer Berechtigung erforderlich:

  • type: Der 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 eine Berechtigung mit type=domain für alle Nutzer in einer bestimmten Domain gilt.

  • role: Das Feld role gibt die Vorgänge an, die die type ausführen kann. Beispielsweise gewährt die Berechtigung type=user und role=reader einem bestimmten Nutzer Lesezugriff auf die Datei oder den Ordner. Oder eine Berechtigung mit type=domain und role=commenter ermöglicht es allen Nutzern in der Domain, einer Datei Kommentare hinzuzufügen. 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 einen emailAddress angeben, um den jeweiligen Nutzer oder die Gruppe mit der Berechtigung zu verknüpfen.

Wenn Sie eine Berechtigung mit type=domain erstellen, müssen Sie auch ein domain angeben, um eine bestimmte Domain mit der Berechtigung zu verknüpfen.

So erstellen Sie eine Berechtigung:

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

Beispiel ansehen

Das folgende Codebeispiel zeigt, wie eine Berechtigung erstellt wird. Die Antwort gibt eine Instanz einer Permission-Ressource zurück, einschließlich des 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 Sie Nutzern die Freigabe von Elementen empfehlen können. Sie können Nutzer dazu ermutigen, Elemente für eine spezifischere oder begrenzte Zielgruppe statt für Ihre gesamte Organisation freizugeben. Zielgruppen können Ihnen helfen, die Sicherheit und den Datenschutz Ihrer Daten zu verbessern und es für Nutzer einfacher zu machen, angemessene Freigaben durchzuführen. Weitere Informationen finden Sie unter Zielgruppen.

So verwenden Sie Zielgruppen:

  1. Gehen Sie in der Admin-Konsole zu „Menü“ > Verzeichnis > Zielgruppen.

    „Zielgruppen“ aufrufen

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

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

  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 setzen Sie das Feld domain auf ID.audience.googledomains.com.

Informationen dazu, wie Nutzer mit Zielgruppen interagieren, finden Sie unter Nutzererfahrung bei der Linkfreigabe.

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. Die Antwort gibt eine Liste der Berechtigungen zurück.

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 die Funktionen der Datei prüfen und die UI so rendern, dass die Berechtigungen des aktuellen Nutzers widergespiegelt werden. Wenn der Nutzer beispielsweise keine canComment-Funktion für die Datei hat, sollte die Kommentarfunktion in der UI deaktiviert werden.

Weitere Informationen zu capabilities finden Sie oben im Abschnitt Funktionen.

Zum Prüfen der Funktionen rufen Sie files.get auf, wobei fileId und fields auf das Feld capabilities festgelegt sind. Weitere Informationen zum Zurückgeben 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 Rechte zurück, die der Nutzer mit der Datei hat. Jede Funktion 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 und Ordner in geteilten Ablagen ermitteln

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, der Rolle für einen Ordner oder der Rolle in einer Datei basieren.

Wenn Sie die Quelle der Rolle für eine geteilte Ablage oder für Elemente in dieser Ablage ermitteln möchten, rufen Sie permissions.get auf, wobei fileId, permissionId und fields auf das Feld permissionDetails festgelegt sind. Zum Ermitteln von permissionId verwenden Sie permissions.list mit dem fileId. Setzen Sie den Parameter fields auf permissions/permissionDetails, um das Feld permissionDetails in der permissions.list-Anfrage abzurufen.

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

Beispiel ansehen

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

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

So ändern Sie die Berechtigungen für eine Datei oder einen Ordner, indem Sie die zugewiesene Rolle ändern:

  1. Rufen Sie permissions.update mit der permissionId der Berechtigung zum Ändern und der fileId für die zugehörige Datei, den Ordner oder die geteilte Ablage auf. Zum Ermitteln von permissionId verwenden Sie permissions.list mit dem fileId.

  2. Geben Sie in der Anfrage den neuen role an.

Sie können Berechtigungen für einzelne Dateien oder Ordner in einer geteilten Ablage erteilen, auch wenn der Nutzer oder die Gruppe bereits Mitglied ist. Beispiel: Alex hat role=commenter als Mitglied einer geteilten Ablage. Die Anwendung kann Alex jedoch role=writer für eine Datei in einer geteilten Ablage gewähren. Da die neue Rolle umfangreicher ist als die durch ihre Mitgliedschaft gewährte Rolle, wird die neue Berechtigung 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 eine Datei oder einen Ordner aufheben

Wenn Sie den Zugriff auf eine Datei oder einen Ordner widerrufen möchten, rufen Sie delete mit den fileId und dem permissionId auf, um die Berechtigung zu löschen.

Für Elemente in "Meine Ablage" kann eine übernommene Berechtigung gelöscht werden. Durch das Löschen einer übernommenen Berechtigung wird der Zugriff auf das Element und gegebenenfalls auf untergeordnete Elemente widerrufen.

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

Mit dem Vorgang delete werden auch Berechtigungen gelöscht, die direkt auf eine Datei oder einen Ordner einer geteilten Ablage angewendet wurden.

Beispiel ansehen

Das folgende Codebeispiel zeigt, wie Sie den Zugriff durch Löschen einer permissionId widerrufen können. Wenn der Vorgang erfolgreich ist, ist der Antworttext leer. Verwende permissions.list mit fileId, um zu prüfen, ob die Berechtigung entfernt wurde.

Anfrage

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

Eigentümerschaft einer Datei auf ein anderes Google Workspace-Konto in derselben Organisation übertragen

Die Eigentümerschaft von Dateien in „Meine Ablage“ kann von einem Google Workspace-Konto auf ein anderes Konto in derselben Organisation übertragen werden. Eine Organisation, der eine geteilte Ablage gehört, sind auch Eigentümer der darin enthaltenen Dateien. Daher werden Übertragungen von Eigentumsrechten für Dateien und Ordner in geteilten Ablagen nicht unterstützt. Organisatoren einer geteilten Ablage können Elemente aus dieser geteilten Ablage in ihre eigene „Meine Ablage“ verschieben, wodurch die Eigentümerschaft auf sie übertragen wird.

Führen Sie einen der folgenden Schritte aus, um die Eigentümerschaft einer Datei in „Meine Ablage“ zu übertragen:

  • Erstellen Sie eine Dateiberechtigung, die einem bestimmten Nutzer (type=user) Inhaberzugriff (role=owner) gewährt.

  • Aktualisieren Sie die Berechtigung einer vorhandenen Datei mit role=owner und übertragen Sie die Eigentümerschaft auf den angegebenen Nutzer (transferOwnership=true).

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

Die Eigentümerschaft an Dateien kann von einem Privatnutzerkonto auf ein anderes übertragen werden. Allerdings überträgt Drive die Eigentümerschaft einer Datei erst zwischen zwei Privatnutzerkonten, wenn der potenzielle neue Eigentümer der Übertragung explizit zustimmt. So übertragen Sie die Eigentümerschaft von Dateien von einem Privatnutzerkonto auf ein anderes:

  1. Der aktuelle Inhaber initiiert eine Übertragung der Inhaberschaft, indem er die Dateiberechtigung des potenziellen neuen Inhabers erstellt oder aktualisiert. Die Berechtigung muss die folgenden Einstellungen enthalten: role=writer, type=user und pendingOwner=true. Wenn der neue Eigentümer eine Berechtigung für den potenziellen Eigentümer erstellt, erhält er eine E-Mail-Benachrichtigung mit der Information, dass er aufgefordert wird, die Eigentümerschaft der Datei zu übernehmen.

  2. Der neue Inhaber akzeptiert die Anfrage zur Übertragung der Inhaberschaft, indem er eine Dateiberechtigung erstellt oder aktualisiert. Die Berechtigung muss die folgenden Einstellungen enthalten: role=owner und transferOwnership=true. Wenn der neue Inhaber eine neue Berechtigung erstellt, wird der vorherige Inhaber per E-Mail darüber benachrichtigt, dass die Inhaberschaft übertragen wurde.

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

Mehrere Berechtigungen mit Batchanfragen ändern

Wir empfehlen dringend, Batchanfragen zu verwenden, um mehrere Berechtigungen zu ändern.

Im folgenden Beispiel wird eine Batch-Änderung von Berechtigungen mit einer Clientbibliothek durchgeführt.

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