Subir datos de archivos

La API de Google Drive te permite subir datos de archivos cuando creas o actualizas una File Para obtener información sobre cómo crear una archivo solo de metadatos, como una carpeta, consulta Crea archivos solo de metadatos.

Existen tres tipos de cargas que puedes realizar:

  • Carga simple (uploadType=media): Usa este tipo de carga para transferir un Un archivo multimedia pequeño (de 5 MB o menos) sin proporcionar metadatos. Para realizar un carga simple, consulta Cómo realizar una carga simple.

  • Carga multiparte (uploadType=multipart): Usa este tipo de carga para transfiera un archivo pequeño (de 5 MB o menos) junto con metadatos que describan en una sola solicitud. Para realizar una carga multiparte, consulta Cómo realizar una carga multiparte.

  • Carga reanudable (uploadType=resumable): Usa este tipo de carga para archivos grandes (de más de 5 MB) y cuando exista alta probabilidad de que la red interrupción, como cuando se crea un archivo desde una aplicación móvil. Reanudable cargas son una buena opción para la mayoría de las aplicaciones porque también funcionan para archivos pequeños con un costo mínimo de una solicitud HTTP adicional por carga. Para realizar una carga reanudable, consulta Realiza una carga reanudable carga.

Las bibliotecas cliente de la API de Google implementan al menos uno de estos tipos de cargas. Consulta la biblioteca cliente documentación para obtener detalles adicionales sobre cada uno de los tipos.

Usa PATCH en comparación con PUT

A modo de repaso, el verbo HTTP PATCH admite una actualización parcial de recursos de archivos. mientras que el verbo HTTP PUT admite el reemplazo completo de recursos. Ten en cuenta que PUT puede introducir cambios rotundos cuando se agrega un campo nuevo a un recurso existente.

Cuando subas un recurso de archivo, sigue estos lineamientos:

  • Usa el verbo HTTP documentado en la referencia de la API para la solicitud inicial de para una carga reanudable o para la única solicitud de una carga simple o multiparte.
  • Usa PUT para todas las solicitudes posteriores de una carga reanudable una vez que comenzó la solicitud. Estas solicitudes suben contenido independientemente de la método de pago.

Realiza una carga simple

Para realizar una carga simple, usa el Método files.create con uploadType=media

A continuación, se muestra cómo realizar una carga simple:

HTTP

  1. Crea una solicitud POST al URI del método /upload con la consulta. parámetro de uploadType=media:

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

  2. Agrega los datos del archivo al cuerpo de la solicitud.

  3. Agrega estos encabezados HTTP:

    • Content-Type Se establece en el tipo de medio MIME del objeto que se está recibiendo. cargado.
    • Content-Length Se establece en la cantidad de bytes que subes. Si usas o fragmentada, este encabezado no es obligatorio.

  4. Envía la solicitud. Si la solicitud se realiza correctamente, el servidor muestra el código de estado HTTP 200 OK junto con los metadatos del archivo. {HTTP}

Cuando subes un archivo, se crean metadatos básicos y algunos atributos se infieren del archivo, como el tipo de MIME o modifiedTime. Puedes usar una simple carga en los casos en que hay archivos pequeños y metadatos importante.

Cómo realizar una carga multiparte

Una solicitud de carga multiparte te permite subir metadatos y datos en el mismo para cada solicitud. Usa esta opción si los datos que envías son lo suficientemente pequeños como para volver a subirlos en su totalidad, si la conexión falla.

Para realizar una carga multiparte, usa el Método files.create con uploadType=multipart

A continuación, se muestra cómo realizar una carga multiparte:

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. Crea una solicitud POST al URI del método /upload con la consulta. parámetro de uploadType=multipart:

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

  2. Crea el cuerpo de la solicitud. Dale formato al cuerpo según el tipo de contenido multiparte/relacionado con RFC 2387. que consta de dos partes:

    • Metadatos. Los metadatos deben ir primero y tener un Content-Type Se estableció el encabezado en application/json; charset=UTF-8. Agrega los metadatos del archivo en formato JSON.
    • Contenido multimedia. El contenido multimedia debe ir en segundo lugar y debe tener un encabezado Content-Type de cualquier tipo de MIME. Agrega los datos del archivo a la parte multimedia.

    Identifica cada parte con una string de límite, precedida por dos guiones. En agrega dos guiones después de la última cadena de límite.

  3. Agrega estos encabezados HTTP de nivel superior:

    • Content-Type Se establece en multipart/related y, además, incluye el límite. la cadena que usas para identificar las distintas partes de la solicitud. Para ejemplo: Content-Type: multipart/related; boundary=foo_bar_baz
    • Content-Length. Configurado como la cantidad total de bytes en el cuerpo de la solicitud.

  4. Envía la solicitud.

Para crear o actualizar solo la parte de metadatos, sin los datos asociados, haz lo siguiente: envía una solicitud POST o PATCH al extremo de recurso estándar: https://www.googleapis.com/drive/v3/files Si la solicitud se realiza correctamente, el servidor devuelve el código de estado HTTP 200 OK junto con el nombre metadatos.

Cuando se crean archivos, deben especificar una extensión de archivo en el name del archivo. . Por ejemplo, al crear un archivo de foto JPEG, puedes especificar algo como "name": "photo.jpg" en los metadatos. Las llamadas posteriores a files.get muestran la propiedad fileExtension de solo lectura. que contiene la extensión que se especificó originalmente en el campo name.

Realiza una carga reanudable

Una carga reanudable te permite reanudar una operación de carga después de una comunicación. una falla interrumpe el flujo de datos. Debido a que no es necesario que reinicies cargas de archivos desde el principio, las cargas reanudables también pueden reducir tu ancho de banda si hay una falla en la red.

Las cargas reanudables son útiles cuando el tamaño de tus archivos puede variar mucho o cuando hay un límite de tiempo fijo para las solicitudes (como las tareas en segundo plano del SO móvil y determinadas solicitudes de App Engine). También puedes usar cargas reanudables para situaciones en las que quieres mostrar una barra de progreso de carga.

Una carga reanudable consta de varios pasos de alto nivel:

  1. Envía la solicitud inicial y recupera el URI de la sesión reanudable.
  2. Sube los datos y supervisa el estado de carga.
  3. (Opcional) Si la carga se interrumpe, reanúdala.

Envía la solicitud inicial

Para iniciar una carga reanudable, usa el Método files.create con uploadType=resumable

HTTP

  1. Crea una solicitud POST al URI del método /upload con la consulta. parámetro de uploadType=resumable:

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

    Si la solicitud de inicio se realiza correctamente, la respuesta incluye una 200 OK. Es el código de estado HTTP. Además, incluye un encabezado Location que especifica el URI de la sesión reanudable:

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

    Guarda el URI de la sesión reanudable para poder subir los datos del archivo y realizar consultas el estado de la carga. El URI de la sesión reanudable vence después de una semana.

  2. Si tienes metadatos para el archivo, agrégalos al cuerpo de la solicitud. en formato JSON. De lo contrario, deja el cuerpo de la solicitud vacío.

  3. Agrega estos encabezados HTTP:

    • X-Upload-Content-Type. Es opcional. Se establece en el tipo de MIME de los datos del archivo, que se transfieren en solicitudes posteriores. Si el tipo de MIME de los datos no se especifica en los metadatos ni a través de este encabezado, el objeto se entrega como application/octet-stream..
    • X-Upload-Content-Length. Es opcional. Se establece en la cantidad de bytes de que se transfieren en solicitudes posteriores.
    • Content-Type. Es obligatorio si existen metadatos para el archivo. Establecer en application/json; (charset=UTF-8).
    • Content-Length Es obligatorio, a menos que uses la codificación de transferencia fragmentada. Se establece como la cantidad de bytes en el cuerpo de esta solicitud inicial.

  4. Envía la solicitud. Si la solicitud de inicio de sesión tiene éxito, la incluye un código de estado 200 OK HTTP. Además, la respuesta incluye un encabezado Location que especifica el URI de la sesión reanudable. Utiliza el URI de la sesión reanudable para subir los datos del archivo y consultar estado de carga. El URI de la sesión reanudable vence después de una semana.

  5. Copia y guarda la URL de la sesión reanudable.

  6. Continúa con el paso Sube el contenido.

Sube el contenido

Existen dos formas de subir un archivo con una sesión reanudable:

  • Sube contenido en una sola solicitud: Usa este enfoque cuando el archivo pueda se pueden subir en una solicitud, si no hay un límite de tiempo fijo para solicitud o no necesitas mostrar un indicador de progreso de carga. Esta es mejor porque requiere menos solicitudes y genera una mejor rendimiento.

  • Sube el contenido en varios fragmentos: Usa este enfoque si debes reducir la cantidad de datos transferidos en una sola solicitud. Es posible que necesites para reducir los datos transferidos cuando hay un límite de tiempo fijo para las individuales, como puede ser el caso de ciertas clases de solicitudes de App Engine. Este enfoque también es útil si debes proporcionar un indicador personalizado para para ver el progreso de la carga.

HTTP: solicitud única

  1. Crea una solicitud PUT para el URI de la sesión reanudable.
  2. Agrega los datos del archivo al cuerpo de la solicitud.
  3. Agrega un encabezado HTTP Content-Length, establecido en la cantidad de bytes del archivo.
  4. Envía la solicitud. Si se interrumpe la solicitud de carga o si recibes un 5xx, sigue el procedimiento que se describe en Cómo reanudar una carga interrumpida.

HTTP: Solicitudes múltiples

  1. Crea una solicitud PUT para el URI de la sesión reanudable.

  2. Agrega los datos del fragmento al cuerpo de la solicitud. Crear fragmentos en múltiplos de 256 KB (256 x 1024 bytes) de tamaño, excepto por el último fragmento que completa la carga. El tamaño del fragmento debe ser lo más grande posible para que la carga eficiente.

  3. Agrega estos encabezados HTTP:

    • Content-Length. Se establece en la cantidad de bytes del fragmento actual.
    • Content-Range Se configura para que muestre qué bytes del archivo subes. Para Por ejemplo, Content-Range: bytes 0-524287/2000000 muestra que subes el archivo primeros 524,288 bytes (256 x 1024 x 2) en un archivo de 2,000,000 bytes.

  4. Envía la solicitud y procesa la respuesta. Si la solicitud de carga es interrumpida, o si recibes una respuesta 5xx, sigue el procedimiento de Reanuda una carga interrumpida.

  5. Repite los pasos del 1 al 4 para cada fragmento que quede en el archivo. Usa el Range en la respuesta para determinar dónde comenzar el siguiente fragmento. No asumas que el servidor recibió todos los bytes enviados en la solicitud anterior.

Cuando se complete la carga del archivo, recibirás un 200 OK o La respuesta de 201 Created, junto con todos los metadatos asociados con el recurso.

Reanuda una carga interrumpida

Si una solicitud de carga se interrumpe antes de una respuesta, o si recibes una respuesta 503 Service Unavailable, debes reanudar la carga interrumpida.

HTTP

  1. Crea una solicitud PUT vacía para el URI de sesión reanudable a fin de solicitar el estado de la carga.

  2. Agrega un encabezado Content-Range para indicar que la posición actual en el se desconoce. Por ejemplo, establece Content-Range en */2000000 si tu la longitud total del archivo es de 2,000,000 bytes. Si desconoces el tamaño completo establece Content-Range en */*.

  3. Envía la solicitud.

  4. Procesa la respuesta:

    • Una respuesta 200 OK o 201 Created indica que se completó la carga y que no es necesario realizar ninguna otra acción.
    • Una respuesta 308 Resume Incomplete indica que debes continuar para subir el archivo.
    • Una respuesta 404 Not Found indica que la sesión de carga venció y la carga debe reiniciarse desde el principio.

  5. Si recibiste una respuesta 308 Resume Incomplete, procesa el Encabezado Range de la respuesta para determinar qué bytes recibió el servidor. Si el botón no tiene un encabezado Range, no se recibieron bytes. Por ejemplo, un encabezado Range de bytes=0-42 indica que el primer se recibieron 43 bytes del archivo y que el siguiente fragmento que comenzaría con el byte 44.

  6. Ahora que sabes dónde reanudar la carga, sube el archivo. comenzando con el siguiente byte. Incluye un Content-Range para indicar qué parte del archivo envías. Para Por ejemplo, Content-Range: bytes 43-1999999 indica que enviar bytes 44 a 2,000,000.

Cómo solucionar errores de carga de contenido multimedia

Cuando subas contenido multimedia, sigue estas prácticas recomendadas para solucionar errores:

  • En el caso de los errores 5xx, reanuda o reintenta las cargas que no se hayan realizado de forma correcta debido a la conexión interrupciones. Para obtener más información sobre cómo manejar los errores 5xx, consulta Errores 500, 502, 503 y 504.
  • Para los errores 403 rate limit, vuelve a intentar la carga. Para obtener más información manejar errores 403 rate limit, consulta error 403: rateLimitExceeded
  • Si hay algún error 4xx (incluido 403) durante una carga reanudable, reinicia la carga. Estos errores indican que la sesión de carga venció y debe reiniciada mediante la solicitud de un nuevo URI de sesión. Subir sesiones también vencen después de una semana de inactividad.

Importar a tipos de Documentos de Google

Cuando crees un archivo en Drive, quizás quieras convertir a un tipo de archivo de Google Workspace, como Documentos de Google o Hojas de cálculo. Por ejemplo, quizás quieres transformar un documento de tu procesador de texto favorito en un documento de Documentos para aprovechar atributos.

Para convertir un archivo a un tipo de archivo específico de Google Workspace, especifica la Google Workspace mimeType durante la creación del archivo.

A continuación, se muestra cómo convertir un archivo CSV en una hoja de 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({
      requestBody: 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;
        }
    }
}

Para ver si hay una conversión disponible, verifica el array importFormats del recurso about antes de crear el archivo. Las conversiones admitidas están disponibles de forma dinámica en este array. Algunos ejemplos los siguientes son los formatos de importación:

DePara
Microsoft Word, texto de OpenDocument, HTML, RTF, texto sin formatoDocumentos de Google
Microsoft Excel, OpenDocument Spreadsheet, CSV, TSV, texto sin formatoHojas de cálculo de Google
Microsoft PowerPoint, OpenDocument PresentationPresentaciones de Google
JPEG, PNG, GIF, BMP y PDFDocumentos de Google (incorpora la imagen en un documento)
Texto sin formato (tipo MIME especial), JSONGoogle Apps Script

Cuando subes y conviertes contenido multimedia durante una solicitud update en una de Documentos, Hojas de cálculo o Presentaciones, la se reemplaza todo el contenido del documento.

Cuando conviertes una imagen en un archivo de Documentos, Drive usa Reconocimiento óptico de caracteres (OCR) para convertir la imagen en texto. Puedes mejorar la calidad del algoritmo de OCR especificando el BCP aplicable Código de idioma 47 en la ocrLanguage parámetro. El texto extraído aparece en el Documento junto a la imagen incorporada.

Usa un ID generado previamente para subir archivos

La API de Drive te permite recuperar una lista de IDs de archivos generados previamente que se usan para subir y crear recursos. Las solicitudes de carga y creación de archivos pueden estos IDs pregenerados. Establece el campo id en los metadatos del archivo.

Para crear IDs pregenerados, llama a files.generateIds con el la cantidad de IDs que se crearán.

Puedes volver a intentar cargas de forma segura con IDs pregenerados si hay un problema tiempo de espera o error del servidor. Si el archivo se creó correctamente, las siguientes los reintentos muestran un error HTTP 409 y no crean archivos duplicados.

Define texto indexable para tipos de archivos desconocidos

Los usuarios pueden usar la IU de Drive para encontrar contenido de documentos. También puedes usa files.list y fullText para buscar contenido en tu app. Para obtener más información, consulta Buscar archivos y carpetas.

Drive indexa automáticamente los documentos para la búsqueda cuando reconoce el tipo de archivo, incluidos los documentos de texto, los PDF, las imágenes con texto y y otros tipos comunes. Si tu app guarda otros tipos de archivos (como dibujos, videos y accesos directos), puedes mejorar la visibilidad si proporcionas texto indexable en el campo contentHints.indexableText del archivo.

Para obtener más información sobre el texto indexable, consulta Administra archivos metadatos.