फ़ाइल डेटा अपलोड करें

File बनाते या अपडेट करते समय, Google Drive API से फ़ाइल का डेटा अपलोड किया जा सकता है. सिर्फ़ मेटाडेटा वाली फ़ाइल, जैसे कि फ़ोल्डर बनाने के तरीके के बारे में जानने के लिए, सिर्फ़ मेटाडेटा वाली फ़ाइलें बनाना देखें.

ये तीन तरह के वीडियो अपलोड किए जा सकते हैं:

  • आसान अपलोड (uploadType=media): मेटाडेटा दिए बिना, छोटी मीडिया फ़ाइल (5 एमबी या इससे कम) ट्रांसफ़र करने के लिए, इस अपलोड टाइप का इस्तेमाल करें. आसानी से अपलोड करने के लिए, आसान अपलोड करने का तरीका लेख पढ़ें.

  • कई हिस्सों में अपलोड (uploadType=multipart): "एक ही अनुरोध में फ़ाइल के बारे में जानकारी देने वाले मेटाडेटा के साथ-साथ छोटी फ़ाइल (पांच एमबी या इससे कम) को ट्रांसफ़र करने के लिए, इस अपलोड टाइप का इस्तेमाल करें. कई हिस्सों में अपलोड करने के लिए, कई हिस्सों में अपलोड करने की सुविधा अपलोड करना देखें.

  • फिर से शुरू किए जाने लायक अपलोड (uploadType=resumable): इस अपलोड टाइप का इस्तेमाल बड़ी फ़ाइलों (पांच एमबी से बड़ी) के लिए करें और जब नेटवर्क में रुकावट आने की संभावना ज़्यादा हो, जैसे कि किसी मोबाइल ऐप्लिकेशन से फ़ाइल बनाते समय. फिर से शुरू किए जा सकने वाले अपलोड, ज़्यादातर ऐप्लिकेशन के लिए अच्छे विकल्प हैं, क्योंकि वे छोटी फ़ाइलों के लिए भी काम करते हैं. इसके लिए, आपको हर अपलोड के लिए कम से कम एक एचटीटीपी अनुरोध करना होता है. फिर से शुरू किए जा सकने वाले अपलोड को करने के लिए, फिर से शुरू किया जा सकने वाला अपलोड करना देखें.

Google API क्लाइंट लाइब्रेरी, इनमें से कम से कम कोई एक अपलोड टाइप लागू करती है. हर टाइप के इस्तेमाल के तरीके के बारे में ज़्यादा जानने के लिए, क्लाइंट लाइब्रेरी का दस्तावेज़ देखें.

PATCH बनाम PUT का इस्तेमाल करें

आपको याद दिला दें कि एचटीटीपी क्रिया PATCH में फ़ाइल के रिसॉर्स का कुछ हिस्सा अपडेट किया जाता है, जबकि एचटीटीपी क्रिया PUT में पूरी तरह से रिसॉर्स को बदलने की सुविधा मिलती है. ध्यान दें कि किसी मौजूदा संसाधन में नया फ़ील्ड जोड़ते समय PUT, नुकसान पहुंचा सकने वाले बदलाव कर सकता है.

फ़ाइल संसाधन अपलोड करते समय, इन दिशा-निर्देशों का पालन करें:

  • डेटा को फिर से शुरू करने के लिए शुरुआती अनुरोध के लिए या किसी सामान्य या एक से ज़्यादा हिस्सों वाले अपलोड के अनुरोध के लिए, एपीआई रेफ़रंस पर दर्ज एचटीटीपी क्रिया का इस्तेमाल करें.
  • अनुरोध शुरू होने के बाद, फिर से शुरू किए जाने वाले अपलोड के लिए बाद के सभी अनुरोधों के लिए, PUT का इस्तेमाल करें. ये अनुरोध कॉन्टेंट अपलोड कर रहे हैं, भले ही किसी भी तरीके से ऐसा किया जा रहा हो.

आसानी से अपलोड करें

आसानी से अपलोड करने के लिए, uploadType=media के साथ files.create तरीके का इस्तेमाल करें.

आसानी से अपलोड करने का तरीका यहां बताया गया है:

HTTP

  1. uploadType=media के क्वेरी पैरामीटर के साथ तरीके के /upload यूआरआई के लिए POST अनुरोध बनाएं:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=media

  2. अनुरोध के मुख्य हिस्से में फ़ाइल का डेटा जोड़ें.

  3. ये एचटीटीपी हेडर जोड़ें:

    • Content-Type. अपलोड किए जा रहे ऑब्जेक्ट के MIME मीडिया प्रकार पर सेट करें.
    • Content-Length. अपलोड किए जाने वाले बाइट की संख्या पर सेट करें. अगर चंक ट्रांसफ़र एन्कोडिंग का इस्तेमाल किया जाता है, तो इस हेडर की ज़रूरत नहीं होती है.
  4. अनुरोध भेजें. अगर अनुरोध पूरा हो जाता है, तो सर्वर, फ़ाइल के मेटाडेटा के साथ HTTP 200 OK स्टेटस कोड दिखाता है. {एचटीटीपी}

सामान्य अपलोड करने पर, सामान्य मेटाडेटा बनाया जाता है और फ़ाइल से कुछ एट्रिब्यूट का अनुमान लगाया जाता है. जैसे, MIME टाइप या modifiedTime. आप चाहें, तो आसान अपलोड का इस्तेमाल करें. ऐसा उन मामलों में करें जहां आपकी फ़ाइलें छोटी हों और फ़ाइल मेटाडेटा ज़रूरी न हो.

कई हिस्सों में डेटा अपलोड करें

कई हिस्सों में डेटा अपलोड करने के अनुरोध की मदद से, एक ही अनुरोध में मेटाडेटा और डेटा अपलोड किया जा सकता है. अगर आपका भेजा गया डेटा इतना छोटा है कि उसे फिर से अपलोड नहीं किया जा सकता, तो इस विकल्प का इस्तेमाल करें.

एक से ज़्यादा हिस्सों में अपलोड करने के लिए, uploadType=multipart के साथ files.create तरीके का इस्तेमाल करें.

नीचे उन सेगमेंट के बारे में बताया गया है जो एक से ज़्यादा हिस्सों में अपलोड करने का तरीका बताते हैं:

Java

drive/snippets/drive_v3/src/main/java/UploadBasic.java
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.FileContent;
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.File;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;

/* Class to demonstrate use of Drive insert file API */
public class UploadBasic {

  /**
   * Upload new file.
   *
   * @return Inserted file metadata if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static String uploadBasic() 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.
    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();
    // Upload file photo.jpg on drive.
    File fileMetadata = new File();
    fileMetadata.setName("photo.jpg");
    // File's content.
    java.io.File filePath = new java.io.File("files/photo.jpg");
    // Specify media type and file-path for file.
    FileContent mediaContent = new FileContent("image/jpeg", filePath);
    try {
      File file = service.files().create(fileMetadata, mediaContent)
          .setFields("id")
          .execute();
      System.out.println("File ID: " + file.getId());
      return file.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to upload file: " + e.getDetails());
      throw e;
    }
  }
}

Python

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


def upload_basic():
  """Insert new file.
  Returns : Id's of the file uploaded

  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)

    file_metadata = {"name": "download.jpeg"}
    media = MediaFileUpload("download.jpeg", mimetype="image/jpeg")
    # pylint: disable=maybe-no-member
    file = (
        service.files()
        .create(body=file_metadata, media_body=media, fields="id")
        .execute()
    )
    print(f'File ID: {file.get("id")}')

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

  return file.get("id")


if __name__ == "__main__":
  upload_basic()

Node.js

drive/snippets/drive_v3/file_snippets/upload_basic.js
/**
 * Insert new file.
 * @return{obj} file Id
 * */
async function uploadBasic() {
  const fs = require('fs');
  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 requestBody = {
    name: 'photo.jpg',
    fields: 'id',
  };
  const media = {
    mimeType: 'image/jpeg',
    body: fs.createReadStream('files/photo.jpg'),
  };
  try {
    const file = await service.files.create({
      requestBody,
      media: media,
    });
    console.log('File Id:', file.data.id);
    return file.data.id;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveUploadBasic.php
use Google\Client;
use Google\Service\Drive;
# TODO - PHP client currently chokes on fetching start page token
function uploadBasic()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $fileMetadata = new Drive\DriveFile(array(
        'name' => 'photo.jpg'));
        $content = file_get_contents('../files/photo.jpg');
        $file = $driveService->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => 'image/jpeg',
            'uploadType' => 'multipart',
            'fields' => 'id'));
        printf("File ID: %s\n", $file->id);
        return $file->id;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    } 

}

.NET

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

namespace DriveV3Snippets
{
    // Class to demonstrate use of Drive insert file API
    public class UploadBasic
    {
        /// <summary>
        /// Upload new file.
        /// </summary>
        /// <param name="filePath">Image path to upload.</param>
        /// <returns>Inserted file metadata if successful, null otherwise.</returns>
        public static string DriveUploadBasic(string filePath)
        {
            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"
                });

                // Upload file photo.jpg on drive.
                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name = "photo.jpg"
                };
                FilesResource.CreateMediaUpload request;
                // Create a new file on drive.
                using (var stream = new FileStream(filePath,
                           FileMode.Open))
                {
                    // Create a new file, with metadata and stream.
                    request = service.Files.Create(
                        fileMetadata, stream, "image/jpeg");
                    request.Fields = "id";
                    request.Upload();
                }

                var file = request.ResponseBody;
                // Prints the uploaded file id.
                Console.WriteLine("File ID: " + file.Id);
                return file.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is FileNotFoundException)
                {
                    Console.WriteLine("File not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

HTTP

  1. uploadType=multipart के क्वेरी पैरामीटर के साथ तरीके के /upload यूआरआई के लिए POST अनुरोध बनाएं:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart

  2. अनुरोध का मुख्य हिस्सा लिखें. मुख्य भाग को एक से ज़्यादा हिस्सों/मिलते-जुलते कॉन्टेंट टाइप आरएफ़सी 2387 के मुताबिक फ़ॉर्मैट करें, जिसमें दो हिस्से होते हैं:

    • मेटाडेटा. मेटाडेटा पहले आना चाहिए और इसमें Content-Type हेडर को application/json; charset=UTF-8 पर सेट होना चाहिए. JSON फ़ॉर्मैट में फ़ाइल का मेटाडेटा जोड़ें.
    • मीडिया. मीडिया दूसरे फ़ॉर्मैट में होना चाहिए और उसमें किसी भी MIME टाइप का Content-Type हेडर होना चाहिए. मीडिया वाले हिस्से में फ़ाइल का डेटा जोड़ें.

    हर हिस्से की पहचान उस सीमा वाली स्ट्रिंग से करें जिसमें पहले दो हाइफ़न लगे हैं. इसके अलावा, आखिरी स्ट्रिंग के बाद दो हाइफ़न जोड़ें.

  3. ये टॉप-लेवल एचटीटीपी हेडर जोड़ें:

    • Content-Type. multipart/related पर सेट करें और अनुरोध के अलग-अलग हिस्सों की पहचान के लिए इस्तेमाल की जाने वाली सीमा स्ट्रिंग शामिल करें. उदाहरण के लिए: Content-Type: multipart/related; boundary=foo_bar_baz
    • Content-Length. अनुरोध के मुख्य हिस्से में कुल बाइट की संख्या सेट करें.
  4. अनुरोध भेजें.

सिर्फ़ मेटाडेटा वाला हिस्सा बनाने या अपडेट करने के लिए, उससे जुड़े डेटा के बिना, स्टैंडर्ड रिसॉर्स एंडपॉइंट पर POST या PATCH अनुरोध भेजें: https://www.googleapis.com/drive/v3/files अनुरोध पूरा होने पर, सर्वर, फ़ाइल के मेटाडेटा के साथ HTTP 200 OK स्टेटस कोड दिखाता है.

फ़ाइलें बनाते समय, उन्हें फ़ाइल के name फ़ील्ड में फ़ाइल एक्सटेंशन तय करना चाहिए. उदाहरण के लिए, JPEG फ़ाइल बनाते समय, मेटाडेटा में "name": "photo.jpg" जैसा कुछ डाला जा सकता है. इसके बाद files.get कॉल करने पर, रीड-ओनली fileExtension प्रॉपर्टी दिखती है. इसमें मूल रूप से name फ़ील्ड में दिया गया एक्सटेंशन होता है.

फिर से शुरू किया जा सकने वाला अपलोड करना

फिर से शुरू किए जाने लायक अपलोड की मदद से कम्यूनिकेशन के दौरान, डेटा के फ़्लो में रुकावट आने के बाद अपलोड की कार्रवाई फिर से शुरू की जा सकती है. बड़े फ़ाइल अपलोड को शुरू से ही रीस्टार्ट करने की ज़रूरत नहीं होती. इसलिए, नेटवर्क के काम न करने पर भी, फिर से शुरू किए जा सकने वाले अपलोड, बैंडविथ के इस्तेमाल को कम कर सकते हैं.

फिर से शुरू किए जा सकने वाले अपलोड तब फ़ायदेमंद होते हैं, जब आपकी फ़ाइल का साइज़ काफ़ी अलग हो सकता है या जब अनुरोधों को पूरा करने की तय समयसीमा हो (जैसे कि मोबाइल ओएस के बैकग्राउंड में चल रहे टास्क और कुछ खास App Engine अनुरोध). आप उन स्थितियों के लिए भी फिर से शुरू किए जा सकने वाले अपलोड इस्तेमाल कर सकते हैं जहां आपको अपलोड का प्रोग्रेस बार दिखाना है.

फिर से शुरू किए जा सकने वाले अपलोड में कई हाई-लेवल चरण शामिल हैं:

  1. शुरुआती अनुरोध भेजें और फिर से शुरू किए जा सकने वाले सेशन यूआरआई को फिर से पाएं.
  2. डेटा अपलोड करें और अपलोड की स्थिति मॉनिटर करें.
  3. (ज़रूरी नहीं) अगर अपलोड में रुकावट आती है, तो अपलोड को फिर से शुरू करें.

शुरुआती अनुरोध भेजें

फिर से शुरू किए जाने लायक अपलोड शुरू करने के लिए, uploadType=resumable के साथ files.create तरीके का इस्तेमाल करें.

HTTP

  1. uploadType=resumable के क्वेरी पैरामीटर के साथ तरीके के /upload यूआरआई के लिए POST अनुरोध बनाएं:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable

    अगर अनुरोध पूरा हो जाता है, तो रिस्पॉन्स में एक 200 OK एचटीटीपी स्टेटस कोड शामिल होता है. इसके अलावा, इसमें एक Location हेडर शामिल होता है, जो फिर से शुरू किए जा सकने वाले सेशन यूआरआई के बारे में बताता है:

    HTTP/1.1 200 OK
    Location: https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable&upload_id=xa298sd_sdlkj2
    Content-Length: 0
    

    फिर से शुरू किए जा सकने वाले सेशन यूआरआई को सेव करें, ताकि आप फ़ाइल का डेटा अपलोड कर सकें और अपलोड के स्टेटस के बारे में क्वेरी कर सकें. फिर से शुरू किए जा सकने वाले सेशन यूआरआई की समयसीमा एक हफ़्ते के बाद खत्म हो जाती है.

  2. अगर आपके पास फ़ाइल के लिए मेटाडेटा है, तो अनुरोध के मुख्य हिस्से में JSON फ़ॉर्मैट में मेटाडेटा जोड़ें. अगर ऐसा नहीं है, तो अनुरोध का मुख्य हिस्सा खाली छोड़ दें.

  3. ये एचटीटीपी हेडर जोड़ें:

    • X-Upload-Content-Type. ज़रूरी नहीं. फ़ाइल डेटा के MIME प्रकार पर सेट करें, जिसे बाद के अनुरोधों में ट्रांसफ़र किया जाता है. अगर मेटाडेटा में या इस हेडर के ज़रिए MIME टाइप के डेटा की जानकारी नहीं दी गई है, तो ऑब्जेक्ट को application/octet-stream. के तौर पर दिखाया जाता है
    • X-Upload-Content-Length. ज़रूरी नहीं. फ़ाइल डेटा के बाइट की संख्या पर सेट करें, जिसे बाद के अनुरोधों में ट्रांसफ़र किया जाता है.
    • Content-Type. अगर आपके पास फ़ाइल के लिए मेटाडेटा है, तो यह ज़रूरी है. application/json; charset=UTF-8 पर सेट करें.
    • Content-Length. अगर आप चंक ट्रांसफ़र एन्कोडिंग का इस्तेमाल नहीं करते, तो यह ज़रूरी है. इस शुरुआती अनुरोध के मुख्य हिस्से में बाइट की संख्या पर सेट करें.
  4. अनुरोध भेजें. अगर सेशन शुरू करने का अनुरोध पूरा हो जाता है, तो जवाब में एक 200 OK HTTP स्टेटस कोड शामिल होता है. इसके अलावा, रिस्पॉन्स में एक Location हेडर शामिल होता है, जो फिर से शुरू किए जा सकने वाले सेशन यूआरआई के बारे में बताता है. फ़ाइल का डेटा अपलोड करने और अपलोड की स्थिति के बारे में क्वेरी करने के लिए, फिर से शुरू किए जा सकने वाले सेशन यूआरआई का इस्तेमाल करें. फिर से शुरू किए जा सकने वाले सेशन यूआरआई की समयसीमा एक हफ़्ते के बाद खत्म हो जाती है.

  5. फिर से शुरू किए जा सकने वाले सेशन के यूआरएल को कॉपी और सेव करें.

  6. कॉन्टेंट अपलोड करना पर जाएं.

कॉन्टेंट अपलोड करना

दोबारा शुरू किए जा सकने वाले सेशन में फ़ाइल अपलोड करने के दो तरीके हैं:

  • एक ही अनुरोध में कॉन्टेंट अपलोड करना: इस तरीके का इस्तेमाल तब करें, जब फ़ाइल को एक अनुरोध में अपलोड किया जा सकता हो, अगर किसी एक अनुरोध के लिए कोई तय समयसीमा नहीं है या आपको अपलोड की स्थिति दिखाने वाला इंडिकेटर दिखाने की ज़रूरत नहीं है. यह तरीका सबसे अच्छा है, क्योंकि इसके लिए कम अनुरोधों की ज़रूरत होती है और इससे बेहतर नतीजे मिलते हैं.
  • कॉन्टेंट को कई हिस्सों में अपलोड करना: अगर आपको किसी एक अनुरोध में ट्रांसफ़र किए गए डेटा को कम करना है, तो इस तरीके का इस्तेमाल करें. जब अलग-अलग अनुरोधों के लिए तय समयसीमा तय होती है, तो आपको ट्रांसफ़र किए गए डेटा को कम करने की ज़रूरत पड़ सकती है. जैसा कि App Engine के अनुरोधों की कुछ क्लास के लिए किया जाता है. यह तरीका तब भी काम आता है, जब आपको अपलोड की प्रोग्रेस दिखाने के लिए कस्टमाइज़ किया गया इंडिकेटर देना ज़रूरी हो.

एचटीटीपी - एक अनुरोध

  1. फिर से शुरू किए जा सकने वाले सेशन यूआरआई के लिए, PUT अनुरोध बनाएं.
  2. अनुरोध के मुख्य हिस्से में फ़ाइल का डेटा जोड़ें.
  3. कॉन्टेंट की लंबाई वाला एचटीटीपी हेडर जोड़ें. यह हेडर फ़ाइल में बाइट की संख्या पर सेट होना चाहिए.
  4. अनुरोध भेजें. अगर अपलोड करने के अनुरोध में रुकावट आती है या आपको 5xx जवाब मिलता है, तो रोके गए अपलोड को फिर से शुरू करें में दिया गया तरीका अपनाएं.

एचटीटीपी - एक से ज़्यादा अनुरोध

  1. फिर से शुरू किए जा सकने वाले सेशन यूआरआई के लिए, PUT अनुरोध बनाएं.

  2. समूह का डेटा, अनुरोध के मुख्य हिस्से में जोड़ें. साइज़ में 256 केबी (256 x 1024 बाइट) के मल्टीपल में हिस्से बनाएं. हालांकि, आखिरी हिस्से को छोड़कर जिसमें अपलोड पूरा हो. समूह के साइज़ को जितना हो सके उतना बड़ा रखें, ताकि अपलोड सही तरीके से हो.

  3. ये एचटीटीपी हेडर जोड़ें:

    • Content-Length. मौजूदा हिस्से में बाइट की संख्या पर सेट करें.
    • Content-Range. यह दिखाने के लिए सेट करें कि आपने फ़ाइल में कौनसे बाइट अपलोड किए हैं. उदाहरण के लिए, Content-Range: bytes 0-524287/2000000 दिखाता है कि आपने शुरुआती 5,24,288 बाइट (256 x 1024 x 2) को 2,000,000 बाइट वाली फ़ाइल में अपलोड किया है.
  4. अनुरोध भेजें और जवाब को प्रोसेस करें. अगर अपलोड करने के अनुरोध में रुकावट आती है या आपको 5xx जवाब मिलता है, तो जिस अपलोड की प्रोसेस रुक गई है उसे फिर से शुरू करें में दिया गया तरीका अपनाएं.

  5. फ़ाइल में मौजूद हर हिस्से के लिए, पहले से लेकर चौथे चरण तक दोहराएं. रिस्पॉन्स में Range हेडर का इस्तेमाल करके, यह तय करें कि अगला हिस्सा कहां से शुरू करना है. यह न मानें कि सर्वर को पिछले अनुरोध में भेजी गई सभी बाइट मिली हैं.

फ़ाइल अपलोड होने के बाद, आपको 200 OK या 201 Created रिस्पॉन्स के साथ-साथ संसाधन से जुड़ा मेटाडेटा भी मिलेगा.

जिस अपलोड में रुकावट आई थी उसे फिर शुरू करना

अगर जवाब अपलोड होने से पहले ही अपलोड करने का अनुरोध बंद कर दिया जाता है या आपको 503 Service Unavailable जवाब मिलता है, तो आपको रोके गए अपलोड को फिर से शुरू करना होगा.

HTTP

  1. अपलोड की स्थिति का अनुरोध करने के लिए, फिर से शुरू किए जा सकने वाले सेशन यूआरआई के लिए, एक खाली PUT अनुरोध बनाएं.

  2. Content-Range हेडर जोड़ें, ताकि यह बताया जा सके कि फ़ाइल की मौजूदा पोज़िशन की जानकारी मौजूद नहीं है. उदाहरण के लिए, अगर फ़ाइल की कुल लंबाई 20,00,000 बाइट है, तो Content-Range को */2000000 पर सेट करें. अगर आपको फ़ाइल का पूरा साइज़ नहीं पता है, तो Content-Range को */* पर सेट करें.

  3. अनुरोध भेजें.

  4. जवाब को प्रोसेस करें:

    • 200 OK या 201 Created रिस्पॉन्स से पता चलता है कि अपलोड पूरा हो गया है. आपको कुछ और करने की ज़रूरत नहीं है.
    • 308 Resume Incomplete रिस्पॉन्स का मतलब है कि आपको फ़ाइल अपलोड करना जारी रखना होगा.
    • 404 Not Found रिस्पॉन्स से पता चलता है कि अपलोड सेशन खत्म हो गया है और अपलोड को फिर से शुरू करना होगा.
  5. अगर आपको 308 Resume Incomplete जवाब मिला है, तो जवाब के Range हेडर को प्रोसेस करके पता लगाएं कि सर्वर को कौनसे बाइट मिले हैं. अगर जवाब में Range हेडर नहीं है, तो कोई बाइट नहीं मिली है. उदाहरण के लिए, bytes=0-42 का Range हेडर बताता है कि फ़ाइल की पहली 43 बाइट मिली थी और अपलोड किया जाने वाला अगला सेगमेंट, बाइट 44 से शुरू होगा.

  6. अब आपको पता है कि अपलोड को फिर से कहां शुरू करना है, तो अगले बाइट से फ़ाइल अपलोड करना जारी रखें. आपको फ़ाइल का कौनसा हिस्सा भेजना है, यह बताने के लिए Content-Range हेडर शामिल करें. उदाहरण के लिए, Content-Range: bytes 43-1999999 बताता है कि आपने 44 से 20,00,000 तक बाइट भेजे हैं.

मीडिया अपलोड करने से जुड़ी गड़बड़ियां ठीक करना

मीडिया अपलोड करते समय गड़बड़ियों को ठीक करने के लिए ये सबसे सही तरीके अपनाएं:

  • 5xx गड़बड़ियों के लिए, कनेक्शन में आई रुकावट की वजह से पूरे न हो पाने वाले अपलोड को फिर से शुरू करें या दोबारा अपलोड करें. 5xx गड़बड़ियों को ठीक करने के बारे में ज़्यादा जानकारी के लिए, 500, 502, 503, 504 गड़बड़ियां देखें.
  • 403 rate limit गड़बड़ियों के लिए, फिर से अपलोड करने की कोशिश करें. 403 rate limit की गड़बड़ियों को मैनेज करने के बारे में ज़्यादा जानकारी के लिए, 403 कोड वाली गड़बड़ी: rateLimitExceeded देखें.
  • फिर से शुरू किए जाने लायक अपलोड के दौरान किसी भी 4xx गड़बड़ी (403 सहित) के लिए, अपलोड को फिर से शुरू करें. इन गड़बड़ियों से पता चलता है कि अपलोड सेशन की समयसीमा खत्म हो गई है और उसे नए सेशन यूआरआई का अनुरोध करके फिर से शुरू करना चाहिए. एक हफ़्ते तक कोई गतिविधि न होने पर, अपलोड वाले सेशन भी खत्म हो जाते हैं.

Google Docs के किसी दस्तावेज़ में इंपोर्ट करें

Drive में कोई फ़ाइल बनाते समय, हो सकता है कि आप उसे Google Workspace की फ़ाइल, जैसे कि Google Docs या Sheets में बदलना चाहें. उदाहरण के लिए, हो सकता है कि आपको अपने पसंदीदा वर्ड प्रोसेसर से किसी दस्तावेज़ को दस्तावेज़ में बदलना हो, ताकि उसकी सुविधाओं का फ़ायदा लिया जा सके.

किसी फ़ाइल को किसी खास Google Workspace फ़ाइल टाइप में बदलने के लिए, फ़ाइल बनाते समय Google Workspace mimeType बताएं.

CSV फ़ाइल को Google Workspace शीट में बदलने का तरीका यहां बताया गया है:

Java

drive/snippets/drive_v3/src/main/java/UploadWithConversion.java
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.FileContent;
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.File;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;

/* Class to demonstrate Drive's upload with conversion use-case. */
public class UploadWithConversion {

  /**
   * Upload file with conversion.
   *
   * @return Inserted file id if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static String uploadWithConversion() 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.
    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();

    // File's metadata.
    File fileMetadata = new File();
    fileMetadata.setName("My Report");
    fileMetadata.setMimeType("application/vnd.google-apps.spreadsheet");

    java.io.File filePath = new java.io.File("files/report.csv");
    FileContent mediaContent = new FileContent("text/csv", filePath);
    try {
      File file = service.files().create(fileMetadata, mediaContent)
          .setFields("id")
          .execute();
      System.out.println("File ID: " + file.getId());
      return file.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to move file: " + e.getDetails());
      throw e;
    }
  }
}

Python

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


def upload_with_conversion():
  """Upload file with conversion
  Returns: ID of the file uploaded

  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)

    file_metadata = {
        "name": "My Report",
        "mimeType": "application/vnd.google-apps.spreadsheet",
    }
    media = MediaFileUpload("report.csv", mimetype="text/csv", resumable=True)
    # pylint: disable=maybe-no-member
    file = (
        service.files()
        .create(body=file_metadata, media_body=media, fields="id")
        .execute()
    )
    print(f'File with ID: "{file.get("id")}" has been uploaded.')

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

  return file.get("id")


if __name__ == "__main__":
  upload_with_conversion()

Node.js

drive/snippets/drive_v3/file_snippets/upload_with_conversion.js
/**
 * Upload file with conversion
 * @return{obj} file Id
 * */
async function uploadWithConversion() {
  const fs = require('fs');
  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 fileMetadata = {
    name: 'My Report',
    mimeType: 'application/vnd.google-apps.spreadsheet',
  };
  const media = {
    mimeType: 'text/csv',
    body: fs.createReadStream('files/report.csv'),
  };

  try {
    const file = await service.files.create({
      resource: fileMetadata,
      media: media,
      fields: 'id',
    });
    console.log('File Id:', file.data.id);
    return file.data.id;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveUploadWithConversion.php
use Google\Client;
use Google\Service\Drive;
function uploadWithConversion()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $fileMetadata = new Drive\DriveFile(array(
            'name' => 'My Report',
            'mimeType' => 'application/vnd.google-apps.spreadsheet'));
        $content = file_get_contents('../files/report.csv');
        $file = $driveService->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => 'text/csv',
            'uploadType' => 'multipart',
            'fields' => 'id'));
        printf("File ID: %s\n", $file->id);
        return $file->id;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

.NET

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

namespace DriveV3Snippets
{
    // Class to demonstrate Drive's upload with conversion use-case.
    public class UploadWithConversion
    {
        /// <summary>
        /// Upload file with conversion.
        /// </summary>
        /// <param name="filePath">Id of the spreadsheet file.</param>
        /// <returns>Inserted file id if successful, null otherwise.</returns>
        public static string DriveUploadWithConversion(string filePath)
        {
            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"
                });

                // Upload file My Report on drive.
                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name = "My Report",
                    MimeType = "application/vnd.google-apps.spreadsheet"
                };
                FilesResource.CreateMediaUpload request;
                // Create a new drive.
                using (var stream = new FileStream(filePath,
                           FileMode.Open))
                {
                    // Create a new file, with metadata and stream.
                    request = service.Files.Create(
                        fileMetadata, stream, "text/csv");
                    request.Fields = "id";
                    request.Upload();
                }

                var file = request.ResponseBody;
                // Prints the uploaded file id.
                Console.WriteLine("File ID: " + file.Id);
                return file.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is FileNotFoundException)
                {
                    Console.WriteLine("File not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

यह देखने के लिए कि कोई कन्वर्ज़न उपलब्ध है या नहीं, फ़ाइल बनाने से पहले about संसाधन का importFormats कलेक्शन देखें. साथ काम करने वाले कन्वर्ज़न, इस कलेक्शन में डाइनैमिक तौर पर उपलब्ध होते हैं. कुछ सामान्य इंपोर्ट फ़ॉर्मैट हैं:

सेइसके लिए
Microsoft Word, OpenDocument टेक्स्ट, एचटीएमएल, आरटीएफ़, सादा टेक्स्टGoogle Docs
Microsoft Excel, OpenDocument स्प्रेडशीट, CSV, TSV, सादा टेक्स्टGoogle Sheets
Microsoft PowerPoint, OpenDocument प्रज़ेंटेशनGoogle Slides
JPEG, PNG, GIF, BMP, PDFGoogle Docs (दस्तावेज़ में इमेज एम्बेड की जाती है)
सादा टेक्स्ट (खास MIME टाइप), JSONGoogle Apps Script

update के अनुरोध के दौरान, मीडिया को अपलोड करके उसे Docs, Sheets या Slides की फ़ाइल में बदलने पर, दस्तावेज़ का पूरा कॉन्टेंट बदल जाता है.

जब किसी इमेज को दस्तावेज़ में बदला जाता है, तो Drive उसे टेक्स्ट में बदलने के लिए ऑप्टिकल कैरेक्टर रिकग्निशन (ओसीआर) का इस्तेमाल करता है. ocrLanguage पैरामीटर में, लागू होने वाले BCP 47 भाषा कोड को तय करके, ओसीआर एल्गोरिदम की क्वालिटी को बेहतर बनाया जा सकता है. निकाला गया टेक्स्ट एम्बेड की गई इमेज के साथ दस्तावेज़ में दिखता है.

फ़ाइलें अपलोड करने के लिए, पहले से जनरेट किए गए आईडी का इस्तेमाल करें

Drive API की मदद से, पहले से जनरेट किए गए फ़ाइल आईडी की सूची को वापस पाया जा सकता है. इन आईडी का इस्तेमाल संसाधनों को अपलोड करने और बनाने के लिए किया जाता है. अपलोड और फ़ाइल बनाने के अनुरोध, पहले से जनरेट किए गए इन आईडी का इस्तेमाल कर सकते हैं. फ़ाइल मेटाडेटा में id फ़ील्ड को सेट करें.

पहले से जनरेट किए गए आईडी बनाने के लिए, आईडी की संख्या के साथ files.generateIds को कॉल करें.

अगर सर्वर की कोई गड़बड़ी या टाइम आउट नहीं हो रहा है, तो पहले से जनरेट किए गए आईडी की मदद से, सुरक्षित तरीके से दोबारा अपलोड करने की कोशिश की जा सकती है. अगर फ़ाइल बन गई है, तो बाद की कोशिश में HTTP 409 गड़बड़ी दिखती है और वे डुप्लीकेट फ़ाइलें नहीं बनाती हैं.

अज्ञात फ़ाइल टाइप के लिए, इंडेक्स किया जा सकने वाला टेक्स्ट तय करना

उपयोगकर्ता, दस्तावेज़ का कॉन्टेंट ढूंढने के लिए, Drive के यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल कर सकते हैं. अपने ऐप्लिकेशन में मौजूद कॉन्टेंट खोजने के लिए, files.list और fullText फ़ील्ड का भी इस्तेमाल किया जा सकता है. ज़्यादा जानकारी के लिए, फ़ाइलें और फ़ोल्डर खोजें देखें.

Drive, दस्तावेज़ों को खोज के लिए अपने-आप इंडेक्स कर लेता है. ऐसा तब होता है, जब फ़ाइल टाइप की पहचान की जाती है. इनमें टेक्स्ट दस्तावेज़, PDF, टेक्स्ट वाली इमेज, और अन्य सामान्य टाइप शामिल हैं. अगर आपका ऐप्लिकेशन दूसरी तरह की फ़ाइलें (जैसे कि ड्रॉइंग, वीडियो, और शॉर्टकट) सेव करता है, तो फ़ाइल के contentHints.indexableText फ़ील्ड में इंडेक्स किया जा सकने वाला टेक्स्ट डालकर, ऐप्लिकेशन के खोजे जाने की संभावना बढ़ाई जा सकती है.

इंडेक्स किए जा सकने वाले टेक्स्ट के बारे में ज़्यादा जानकारी के लिए, फ़ाइल मेटाडेटा मैनेज करें देखें.