Dateien mit Cloud Storage auf Apple-Plattformen hochladen

Mit Cloud Storage for Firebase können Sie schnell und einfach Dateien in einen Cloud Storage-Bucket hochladen, der von Firebase bereitgestellt und verwaltet wird.

Hinweis: Standardmäßig benötigt ein Cloud Storage for Firebase-Bucket Firebase Authentication, um Aktionen für die Daten oder Dateien des Buckets auszuführen. Sie können Firebase Security Rules in Cloud Storage ändern, um den nicht authentifizierten Zugriff für bestimmte Situationen zuzulassen. In den meisten Fällen empfehlen wir jedoch dringend, den Zugriff einzuschränken und robuste Sicherheitsregeln einzurichten, insbesondere bei Produktions-Apps. Wenn Sie Google App Engine verwenden und einen Standard-Cloud Storage-Bucket mit dem Namensformat *.appspot.com haben, müssen Sie möglicherweise berücksichtigen, wie sich Ihre Sicherheitsregeln auf den Zugriff auf App Engine-Dateien auswirken.

Hinweis: Bei Projekten mit Spark-Abo blockiert Firebase den Upload und das Hosting bestimmter ausführbarer Dateitypen für Windows (Dateien mit den Erweiterungen .exe, .dll und .bat), Android (.apk-Erweiterung) und Apple (.ipa-Erweiterung) durch Cloud Storage for Firebase und Firebase Hosting. Diese Richtlinie soll Missbrauch auf unserer Plattform verhindern. Projekte mit dem Blaze-Tarif sind davon nicht betroffen. Weitere Informationen finden Sie in diesen FAQs.

Referenz erstellen

Wenn Sie eine Datei hochladen möchten, müssen Sie zuerst eine Cloud Storage-Referenz zum Speicherort in Cloud Storage erstellen, an den Sie die Datei hochladen möchten.

Sie können einen Verweis erstellen, indem Sie dem Stammverzeichnis Ihres Cloud Storage-Buckets untergeordnete Pfade anhängen:

Swift

// Create a root reference
let storageRef = storage.reference()

// Create a reference to "mountains.jpg"
let mountainsRef = storageRef.child("mountains.jpg")

// Create a reference to 'images/mountains.jpg'
let mountainImagesRef = storageRef.child("images/mountains.jpg")

// While the file names are the same, the references point to different files
mountainsRef.name == mountainImagesRef.name            // true
mountainsRef.fullPath == mountainImagesRef.fullPath    // false
    

Objective-C

// Create a root reference
FIRStorageReference *storageRef = [storage reference];

// Create a reference to "mountains.jpg"
FIRStorageReference *mountainsRef = [storageRef child:@"mountains.jpg"];

// Create a reference to 'images/mountains.jpg'
FIRStorageReference *mountainImagesRef = [storageRef child:@"images/mountains.jpg"];

// While the file names are the same, the references point to different files
[mountainsRef.name isEqualToString:mountainImagesRef.name];         // true
[mountainsRef.fullPath isEqualToString:mountainImagesRef.fullPath]; // false
  

Sie können keine Daten mit einer Referenz auf die Wurzel Ihres Cloud Storage-Buckets hochladen. Die Referenz muss auf eine untergeordnete URL verweisen.

Dateien hochladen

Sobald du eine Referenz hast, kannst du Dateien auf zwei Arten zu Cloud Storage hochladen:

1. Aus Daten im Arbeitsspeicher hochladen
2. Über eine URL hochladen, die eine Datei auf dem Gerät darstellt

Aus Daten im Arbeitsspeicher hochladen

Die putData:metadata:completion:-Methode ist die einfachste Möglichkeit, eine Datei in Cloud Storage hochzuladen. putData:metadata:completion: nimmt ein NSData-Objekt entgegen und gibt eine FIRStorageUploadTask zurück, mit der du den Upload verwalten und seinen Status beobachten kannst.

Swift

// Data in memory
let data = Data()

// Create a reference to the file you want to upload
let riversRef = storageRef.child("images/rivers.jpg")

// Upload the file to the path "images/rivers.jpg"
let uploadTask = riversRef.putData(data, metadata: nil) { (metadata, error) in
  guard let metadata = metadata else {
    // Uh-oh, an error occurred!
    return
  }
  // Metadata contains file metadata such as size, content-type.
  let size = metadata.size
  // You can also access to download URL after upload.
  riversRef.downloadURL { (url, error) in
    guard let downloadURL = url else {
      // Uh-oh, an error occurred!
      return
    }
  }
}
    

Objective-C

// Data in memory
NSData *data = [NSData dataWithContentsOfFile:@"rivers.jpg"];

// Create a reference to the file you want to upload
FIRStorageReference *riversRef = [storageRef child:@"images/rivers.jpg"];

// Upload the file to the path "images/rivers.jpg"
FIRStorageUploadTask *uploadTask = [riversRef putData:data
                                             metadata:nil
                                           completion:^(FIRStorageMetadata *metadata,
                                                        NSError *error) {
  if (error != nil) {
    // Uh-oh, an error occurred!
  } else {
    // Metadata contains file metadata such as size, content-type, and download URL.
    int size = metadata.size;
    // You can also access to download URL after upload.
    [riversRef downloadURLWithCompletion:^(NSURL * _Nullable URL, NSError * _Nullable error) {
      if (error != nil) {
        // Uh-oh, an error occurred!
      } else {
        NSURL *downloadURL = URL;
      }
    }];
  }
}];
  

Von einer lokalen Datei hochladen

Mit der Methode putFile:metadata:completion: können Sie lokale Dateien wie Fotos und Videos von der Kamera auf die Geräte hochladen. putFile:metadata:completion: nimmt ein NSURL und gibt ein FIRStorageUploadTask zurück, mit dem Sie den Upload verwalten und seinen Status überwachen können.

Swift

// File located on disk
let localFile = URL(string: "path/to/image")!

// Create a reference to the file you want to upload
let riversRef = storageRef.child("images/rivers.jpg")

// Upload the file to the path "images/rivers.jpg"
let uploadTask = riversRef.putFile(from: localFile, metadata: nil) { metadata, error in
  guard let metadata = metadata else {
    // Uh-oh, an error occurred!
    return
  }
  // Metadata contains file metadata such as size, content-type.
  let size = metadata.size
  // You can also access to download URL after upload.
  riversRef.downloadURL { (url, error) in
    guard let downloadURL = url else {
      // Uh-oh, an error occurred!
      return
    }
  }
}
    

Objective-C

// File located on disk
NSURL *localFile = [NSURL URLWithString:@"path/to/image"];

// Create a reference to the file you want to upload
FIRStorageReference *riversRef = [storageRef child:@"images/rivers.jpg"];

// Upload the file to the path "images/rivers.jpg"
FIRStorageUploadTask *uploadTask = [riversRef putFile:localFile metadata:nil completion:^(FIRStorageMetadata *metadata, NSError *error) {
  if (error != nil) {
    // Uh-oh, an error occurred!
  } else {
    // Metadata contains file metadata such as size, content-type, and download URL.
    int size = metadata.size;
    // You can also access to download URL after upload.
    [riversRef downloadURLWithCompletion:^(NSURL * _Nullable URL, NSError * _Nullable error) {
      if (error != nil) {
        // Uh-oh, an error occurred!
      } else {
        NSURL *downloadURL = URL;
      }
    }];
  }
}];
  

Wenn Sie den Upload aktiv verwalten möchten, können Sie die Methoden putData: oder putFile: verwenden und den Uploadvorgang beobachten, anstatt den Abschluss-Handler zu verwenden. Weitere Informationen finden Sie unter Uploads verwalten.

Dateimetadaten hinzufügen

Sie können auch Metadaten beim Hochladen von Dateien angeben. Diese Metadaten enthalten typische Dateimetadateneigenschaften wie name, size und contentType (allgemein als MIME-Typ bezeichnet). Bei der putFile:-Methode wird der Inhaltstyp automatisch aus der NSURL-Dateiendung abgeleitet. Sie können den automatisch erkannten Typ jedoch überschreiben, indem Sie contentType in den Metadaten angeben. Wenn Sie kein contentType angeben und Cloud Storage keinen Standardwert aus der Dateiendung ableiten kann, verwendet Cloud Storage application/octet-stream. Weitere Informationen zu Dateimetadaten finden Sie im Abschnitt Dateimetadaten verwenden.

Swift

// Create storage reference
let mountainsRef = storageRef.child("images/mountains.jpg")

// Create file metadata including the content type
let metadata = StorageMetadata()
metadata.contentType = "image/jpeg"

// Upload data and metadata
mountainsRef.putData(data, metadata: metadata)

// Upload file and metadata
mountainsRef.putFile(from: localFile, metadata: metadata)
    

Objective-C

// Create storage reference
FIRStorageReference *mountainsRef = [storageRef child:@"images/mountains.jpg"];

// Create file metadata including the content type
FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] init];
metadata.contentType = @"image/jpeg";

// Upload data and metadata
FIRStorageUploadTask *uploadTask = [mountainsRef putData:data metadata:metadata];

// Upload file and metadata
uploadTask = [mountainsRef putFile:localFile metadata:metadata];
  

Uploads verwalten

Mit den Methoden pause, resume und cancel können Sie Uploads nicht nur starten, sondern auch pausieren, fortsetzen und abbrechen. Diese Methoden lösen pause-, resume- und cancel-Ereignisse aus. Wenn Sie einen Upload abbrechen, wird er fehlgeschlagen und es wird eine Fehlermeldung angezeigt, dass der Upload abgebrochen wurde.

Swift

// Start uploading a file
let uploadTask = storageRef.putFile(from: localFile)

// Pause the upload
uploadTask.pause()

// Resume the upload
uploadTask.resume()

// Cancel the upload
uploadTask.cancel()
    

Objective-C

// Start uploading a file
FIRStorageUploadTask *uploadTask = [storageRef putFile:localFile];

// Pause the upload
[uploadTask pause];

// Resume the upload
[uploadTask resume];

// Cancel the upload
[uploadTask cancel];
  

Uploadfortschritt im Blick behalten

Sie können Beobachter an FIRStorageUploadTasks anhängen, um den Fortschritt des Uploads zu verfolgen. Wenn Sie einen Beobachter hinzufügen, wird eine FIRStorageHandle zurückgegeben, mit der Sie den Beobachter entfernen können.

Swift

// Add a progress observer to an upload task
let observer = uploadTask.observe(.progress) { snapshot in
  // A progress event occured
}
    

Objective-C

// Add a progress observer to an upload task
FIRStorageHandle observer = [uploadTask observeStatus:FIRStorageTaskStatusProgress
                                              handler:^(FIRStorageTaskSnapshot *snapshot) {
                                                // A progress event occurred
                                              }];
  

Diese Beobachter können einem FIRStorageTaskStatus-Ereignis hinzugefügt werden:

FIRStorageTaskStatus Ereignis	Typische Verwendung
FIRStorageTaskStatusResume	Dieses Ereignis wird ausgelöst, wenn die Aufgabe den Upload startet oder fortsetzt. Es wird häufig in Verbindung mit dem Ereignis FIRStorageTaskStatusPause verwendet.
FIRStorageTaskStatusProgress	Dieses Ereignis wird ausgelöst, wenn Daten in Cloud Storage hochgeladen werden. Es kann verwendet werden, um eine Fortschrittsanzeige für den Upload zu füllen.
FIRStorageTaskStatusPause	Dieses Ereignis wird immer dann ausgelöst, wenn der Upload angehalten wird, und wird häufig in Verbindung mit dem FIRStorageTaskStatusResume-Ereignis verwendet.
FIRStorageTaskStatusSuccess	Dieses Ereignis wird ausgelöst, wenn ein Upload erfolgreich abgeschlossen wurde.
FIRStorageTaskStatusFailure	Dieses Ereignis wird ausgelöst, wenn ein Upload fehlgeschlagen ist. Prüfen Sie den Fehler, um den Grund für den Fehler zu ermitteln.

Wenn ein Ereignis eintritt, wird ein FIRStorageTaskSnapshot-Objekt zurückgegeben. Dieser Snapshot ist eine unveränderliche Ansicht der Aufgabe zum Zeitpunkt des Ereignisses. Dieses Objekt enthält die folgenden Eigenschaften:

Attribut	Typ	Beschreibung
progress	NSProgress	Ein NSProgress-Objekt, das den Fortschritt des Uploads enthält.
error	NSError	Falls beim Upload ein Fehler aufgetreten ist.
metadata	FIRStorageMetadata	Während des Uploads werden Metadaten hochgeladen. Nach einem FIRTaskStatusSuccess-Ereignis enthält die Metadaten der hochgeladenen Datei.
task	FIRStorageUploadTask	Die Aufgabe, deren Snapshot dies ist, mit der die Aufgabe verwaltet werden kann (pause, resume, cancel).
reference	FIRStorageReference	Die Referenz, aus der diese Aufgabe stammt.

Sie können Beobachter auch einzeln, nach Status oder durch Entfernen aller Beobachter entfernen.

Swift

// Create a task listener handle
let observer = uploadTask.observe(.progress) { snapshot in
  // A progress event occurred
}

// Remove an individual observer
uploadTask.removeObserver(withHandle: observer)

// Remove all observers of a particular status
uploadTask.removeAllObservers(for: .progress)

// Remove all observers
uploadTask.removeAllObservers()
    

Objective-C

// Create a task listener handle
FIRStorageHandle observer = [uploadTask observeStatus:FIRStorageTaskStatusProgress
                                              handler:^(FIRStorageTaskSnapshot *snapshot) {
                                                // A progress event occurred
                                              }];

// Remove an individual observer
[uploadTask removeObserverWithHandle:observer];

// Remove all observers of a particular status
[uploadTask removeAllObserversForStatus:FIRStorageTaskStatusProgress];

// Remove all observers
[uploadTask removeAllObservers];
  

Um Speicherlecks zu vermeiden, werden alle Beobachter nach einem FIRStorageTaskStatusSuccess oder FIRStorageTaskStatusFailure entfernt.

Fehlerbehandlung

Es kann verschiedene Gründe für Fehler beim Upload geben, z. B. dass die lokale Datei nicht vorhanden ist oder der Nutzer keine Berechtigung zum Hochladen der gewünschten Datei hat. Weitere Informationen zu Fehlern finden Sie im Abschnitt Fehler beheben.

Vollständiges Beispiel

Unten siehst du ein vollständiges Beispiel für einen Upload mit Fortschrittsüberwachung und Fehlerbehandlung:

Swift

// Local file you want to upload
let localFile = URL(string: "path/to/image")!

// Create the file metadata
let metadata = StorageMetadata()
metadata.contentType = "image/jpeg"

// Upload file and metadata to the object 'images/mountains.jpg'
let uploadTask = storageRef.putFile(from: localFile, metadata: metadata)

// Listen for state changes, errors, and completion of the upload.
uploadTask.observe(.resume) { snapshot in
  // Upload resumed, also fires when the upload starts
}

uploadTask.observe(.pause) { snapshot in
  // Upload paused
}

uploadTask.observe(.progress) { snapshot in
  // Upload reported progress
  let percentComplete = 100.0 * Double(snapshot.progress!.completedUnitCount)
    / Double(snapshot.progress!.totalUnitCount)
}

uploadTask.observe(.success) { snapshot in
  // Upload completed successfully
}

uploadTask.observe(.failure) { snapshot in
  if let error = snapshot.error as? NSError {
    switch (StorageErrorCode(rawValue: error.code)!) {
    case .objectNotFound:
      // File doesn't exist
      break
    case .unauthorized:
      // User doesn't have permission to access file
      break
    case .cancelled:
      // User canceled the upload
      break

    /* ... */

    case .unknown:
      // Unknown error occurred, inspect the server response
      break
    default:
      // A separate error occurred. This is a good place to retry the upload.
      break
    }
  }
}
    

Objective-C

// Local file you want to upload
NSURL *localFile = [NSURL URLWithString:@"path/to/image"];

// Create the file metadata
FIRStorageMetadata *metadata = [[FIRStorageMetadata alloc] init];
metadata.contentType = @"image/jpeg";

// Upload file and metadata to the object 'images/mountains.jpg'
FIRStorageUploadTask *uploadTask = [storageRef putFile:localFile metadata:metadata];

// Listen for state changes, errors, and completion of the upload.
[uploadTask observeStatus:FIRStorageTaskStatusResume handler:^(FIRStorageTaskSnapshot *snapshot) {
  // Upload resumed, also fires when the upload starts
}];

[uploadTask observeStatus:FIRStorageTaskStatusPause handler:^(FIRStorageTaskSnapshot *snapshot) {
  // Upload paused
}];

[uploadTask observeStatus:FIRStorageTaskStatusProgress handler:^(FIRStorageTaskSnapshot *snapshot) {
  // Upload reported progress
  double percentComplete = 100.0 * (snapshot.progress.completedUnitCount) / (snapshot.progress.totalUnitCount);
}];

[uploadTask observeStatus:FIRStorageTaskStatusSuccess handler:^(FIRStorageTaskSnapshot *snapshot) {
  // Upload completed successfully
}];

// Errors only occur in the "Failure" case
[uploadTask observeStatus:FIRStorageTaskStatusFailure handler:^(FIRStorageTaskSnapshot *snapshot) {
  if (snapshot.error != nil) {
    switch (snapshot.error.code) {
      case FIRStorageErrorCodeObjectNotFound:
        // File doesn't exist
        break;

      case FIRStorageErrorCodeUnauthorized:
        // User doesn't have permission to access file
        break;

      case FIRStorageErrorCodeCancelled:
        // User canceled the upload
        break;

      /* ... */

      case FIRStorageErrorCodeUnknown:
        // Unknown error occurred, inspect the server response
        break;
    }
  }
}];
  

Nachdem Sie die Dateien hochgeladen haben, können Sie sie von Cloud Storage herunterladen.