אירוח אתר סטטי באמצעות HTTP

המדריך הזה מתאר איך להגדיר קטגוריה של Cloud Storage לאירוח אתר סטטי בשביל דומיין שנמצא בבעלותכם. דפי אינטרנט סטטיים יכולים להכיל טכנולוגיות בצד הלקוח, כמו HTML, CSS ו-JavaScript. הם לא יכולים להכיל תוכן דינמי, כמו סקריפטים בצד השרת, למשל PHP.

המדריך הזה מראה איך למלא בקשות באמצעות HTTP. למדריך שמשתמש ב-HTTPS, ראו אירוח אתר סטטי.

לדוגמאות ולטיפים בנושא דפי אינטרנט סטטיים, כולל הנחיות לאירוח נכסים סטטיים באתר דינמי, ראו דף אתר סטטי.

מטרות

במדריך הזה תלמדו:

  • להפנות את הדומיין ל-Cloud Storage באמצעות רשומת CNAME.
  • ליצור קטגוריה שמקושרת לדומיין.
  • להעלות את קובצי האתר ולשתף אותם.
  • לבדוק את האתר.

עלויות

המדריך הזה משתמש ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:

  • Cloud Storage

למידע נוסף על החיובים באירוח אתר סטטי, ראו את הטיפ למעקב אחרי החיובים על האחסון, ולפרטים על עלויות Cloud Storage, עיינו בדף תמחור.

לפני שמתחילים

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  5. Make sure that billing is enabled for your Google Cloud project.

  6. אתם צריכים דומיין שאתם מנהלים או הבעלים שלו. אם אין לכם דומיין קיים, יש שירותים רבים שבאמצעותם אפשר לרשום דומיין חדש, כמו Google Domains.

    המדריך זה משתמש בדומיין example.com.

  7. מוודאים שאתם הבעלים או המנהלים של הדומיין שבו תשתמשו. מוודאים שהאימות מתבצע בדומיין ברמה עליונה, כמו example.com, ולא בתת-דומיין, כמו www.example.com.

    הערה: אם אתם הבעלים של הדומיין שמשייכים לקטגוריה, יכול להיות שכבר ביצעתם את השלב הזה בעבר. אם רכשתם את הדומיין דרך Google Domains, האימות מתבצע באופן אוטומטי.

קישור הדומיין ל-Cloud Storage

כדי לקשר את הדומיין ל-Cloud Storage, צריך ליצור רשומת CNAME באמצעות שירות הרישום של הדומיין. רשומת CNAME היא סוג של רשומת DNS. היא מפנה תעבורה שמבקשת כתובת URL מהדומיין שלכם למשאבים שרוצים לספק, במקרה הזה, אובייקטים בקטגוריות של Cloud Storage. בשביל www.example.com, הרשומה CNAME עשויה להכיל את הפרטים הבאים:

NAME                  TYPE     DATA
www                   CNAME    c.storage.googleapis.com.

למידע נוסף על הפניות לכתובת אחרת של CNAME, ראו URI עבור יצירת אימייל חלופי ל-CNAME.

כדי לקשר את הדומיין ל-Cloud Storage:

  1. יוצרים רשומת CNAME שמצביעה אל c.storage.googleapis.com..

    שירות הרישום של הדומיין צריך לאפשר לנהל את הדומיין, כולל הוספה של רשומת CNAME. לדוגמה, אם משתמשים ב-Google Domains, אפשר למצוא הוראות להוספת רשומות משאבים בדף העזרה של Google Domains.

יצירת קטגוריה

יוצרים קטגוריה שהשם שלה תואם ל-CNAME שיצרתם בשביל הדומיין.

לדוגמה, אם מוסיפים רשומת CNAME שמצביעה מתת-הדומיין www של example.com אל c.storage.googleapis.com., אז יוצרים קטגוריה בשם www.example.com.

כדי ליצור קטגוריה:

המסוף

  1. במסוף Google Cloud, נכנסים לדף Buckets ב-Cloud Storage.

    כניסה לדף Buckets

  2. לוחצים על Create כדי לפתוח את הטופס ליצירת קטגוריה.

  3. מזינים את פרטי הקטגוריה ולוחצים על Continue כדי להשלים כל שלב:

    • ה-שם של הקטגוריה, שתואם לשם המארח שמשויך לרשומת CNAME שלכם.

    • בוחרים את Location type ואת Location של הקטגוריה. לדוגמה Region ו-us-east1.

    • בוחרים Standard Storage בשביל Storage class.

    • בוחרים Uniform בשביל Access control.

  4. לוחצים על Create.

אם הפעולה מצליחה, אז מועברים לדף של הקטגוריה עם הטקסט "There are no live objects in this bucket."

שורת הפקודה

gcloud

משתמשים בפקודה יצירת קטגוריות:

gcloud storage buckets create gs://www.example.com

אם הפעולה הצליחה, הפקודה תחזיר:

Creating gs://www.example.com/...

gsutil

משתמשים בפקודה gsutil mb:

gsutil mb gs://www.example.com

אם הפעולה הצליחה, הפקודה תחזיר:

Creating gs://www.example.com/...

ספריות לקוח

C++

מידע נוסף מופיע במאמרי העזרה של Cloud Storage C++ API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& storage_class, std::string const& location) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.CreateBucket(bucket_name, gcs::BucketMetadata()
                                           .set_storage_class(storage_class)
                                           .set_location(location));
  if (!bucket_metadata) throw std::move(bucket_metadata).status();

  std::cout << "Bucket " << bucket_metadata->name() << " created."
            << "\nFull Metadata: " << *bucket_metadata << "\n";
}

C#

מידע נוסף מופיע במאמרי העזרה של Cloud Storage C# API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class CreateRegionalBucketSample
{
    /// <summary>
    /// Creates a storage bucket with region.
    /// </summary>
    /// <param name="projectId">The ID of the project to create the buckets in.</param>
    /// <param name="location">The location of the bucket. Object data for objects in the bucket resides in
    /// physical storage within this region. Defaults to US.</param>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="storageClass">The bucket's default storage class, used whenever no storageClass is specified
    /// for a newly-created object. This defines how objects in the bucket are stored
    /// and determines the SLA and the cost of storage. Values include MULTI_REGIONAL,
    /// REGIONAL, STANDARD, NEARLINE, COLDLINE, ARCHIVE, and DURABLE_REDUCED_AVAILABILITY.
    /// If this value is not specified when the bucket is created, it will default to
    /// STANDARD.</param>
    public Bucket CreateRegionalBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string location = "us-west1",
        string storageClass = "REGIONAL")
    {
        var storage = StorageClient.Create();
        Bucket bucket = new Bucket
        {
            Location = location,
            Name = bucketName,
            StorageClass = storageClass
        };
        var newlyCreatedBucket = storage.CreateBucket(projectId, bucket);
        Console.WriteLine($"Created {bucketName}.");
        return newlyCreatedBucket;
    }
}

Go

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Go API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// createBucketClassLocation creates a new bucket in the project with Storage class and
// location.
func createBucketClassLocation(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINE",
		Location:     "asia",
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v\n", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	return nil
}

Java

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Java API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class CreateBucketWithStorageClassAndLocation {
  public static void createBucketWithStorageClassAndLocation(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    // See this documentation for other valid locations:
    // http://g.co/cloud/storage/docs/bucket-locations#location-mr
    String location = "ASIA";

    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                .setStorageClass(storageClass)
                .setLocation(location)
                .build());

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in "
            + bucket.getLocation()
            + " with storage class "
            + bucket.getStorageClass());
  }
}

Node.js

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Node.js API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

// The name of a location
// See this documentation for other valid locations:
// http://g.co/cloud/storage/docs/locations#location-mr
// const location = 'ASIA';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see https://cloud.google.com/docs/authentication/production or https://googleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storage();

async function createBucketWithStorageClassAndLocation() {
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    [storageClass]: true,
  });

  console.log(
    `${bucket.name} created with ${storageClass} class in ${location}`
  );
}

createBucketWithStorageClassAndLocation().catch(console.error);

PHP

מידע נוסף מופיע במאמרי העזרה של Cloud Storage PHP API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

use Google\Cloud\Storage\StorageClient;

/**
 * Create a new bucket with a custom default storage class and location.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function create_bucket_class_location(string $bucketName): void
{
    $storage = new StorageClient();
    $storageClass = 'COLDLINE';
    $location = 'ASIA';
    $bucket = $storage->createBucket($bucketName, [
        'storageClass' => $storageClass,
        'location' => $location,
    ]);

    $objects = $bucket->objects([
        'encryption' => [
            'defaultKmsKeyName' => null,
        ]
    ]);

    printf('Created bucket %s in %s with storage class %s', $bucketName, $storageClass, $location);
}

Python

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Python API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

from google.cloud import storage

def create_bucket_class_location(bucket_name):
    """
    Create a new bucket in the US region with the coldline storage
    class
    """
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "COLDLINE"
    new_bucket = storage_client.create_bucket(bucket, location="us")

    print(
        "Created bucket {} in {} with storage class {}".format(
            new_bucket.name, new_bucket.location, new_bucket.storage_class
        )
    )
    return new_bucket

Ruby

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Ruby API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

def create_bucket_class_location bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.create_bucket bucket_name,
                                  location:      "ASIA",
                                  storage_class: "COLDLINE"

  puts "Created bucket #{bucket.name} in #{bucket.location} with #{bucket.storage_class} class"
end

‫API בארכיטקטורת REST

‫API בפורמט JSON

  1. מקבלים אסימון גישה להרשאה מ-OAuth 2.0 Playground. מגדירים את ה-Playground לשימוש בפרטי הכניסה שלכם ב-OAuth. הוראות מפורטות מופיעות במאמר אימות API.

  2. יוצרים קובץ JSON שמקצה את שם האתר למאפיין name:

    {
  "name": "www.example.com"
}

  3. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט JSON. בשביל www.example.com:

    curl -X POST --data-binary @website-bucket-name.json \
  -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b?project=my-static-website"

‫API בפורמט XML

  1. מקבלים אסימון גישה להרשאה מ-OAuth 2.0 Playground. מגדירים את ה-Playground לשימוש בפרטי הכניסה שלכם ב-OAuth. הוראות מפורטות מופיעות במאמר אימות API.

  2. משתמשים ב-cURL כדי לקרוא ל-API בפורמט XML כדי ליצור קטגוריה עם שם האתר. בשביל www.example.com:

    curl -X PUT \
  -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
  -H "x-goog-project-id: my-static-website" \
  "https://storage.googleapis.com/www.example.com"

העלאת הקבצים של האתר

כדי להוסיף לקטגוריה את הקבצים שרוצים להציג באתר:

המסוף

  1. במסוף Google Cloud, נכנסים לדף Buckets ב-Cloud Storage.

    כניסה לדף Buckets

  2. ברשימת הקטגוריות, לוחצים על שם הקטגוריה שיצרתם.

  3. לוחצים על הלחצן Upload files בכרטיסייה Objects.

  4. בתיבת הדו-שיח של הקובץ, מחפשים את הקובץ הרצוי ובוחרים אותו.

בסיום ההעלאה אמורים להופיע שם הקובץ ופרטי הקובץ בקטגוריה.

שורת הפקודה

gcloud

כדי להעתיק קבצים לקטגוריה, משתמשים בפקודה gcloud storage cp. לדוגמה, כדי להעתיק את הקובץ index.html מהמיקום הנוכחי שלו, Desktop:

gcloud storage cp Desktop/index.html gs://www.example.com

אם הפעולה בוצעה ללא שגיאות, התשובה תיראה כמו בדוגמה הבאה:

Completed files 1/1 | 164.3kiB/164.3kiB

gsutil

כדי להעתיק קבצים לקטגוריה, משתמשים בפקודה gsutil cp. לדוגמה, כדי להעתיק את הקובץ index.html מהמיקום הנוכחי שלו, Desktop:

gsutil cp Desktop/index.html gs://www.example.com

אם הפעולה הצליחה, הפקודה תחזיר:

Copying file://Desktop/index.html [Content-Type=text/html]...
Uploading   gs://www.example.com/index.html:       0 B/2.58 KiB
Uploading   gs://www.example.com/index.html:       2.58 KiB/2.58 KiB

ספריות לקוח

C++

מידע נוסף מופיע במאמרי העזרה של Cloud Storage C++ API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& file_name,
   std::string const& bucket_name, std::string const& object_name) {
  // Note that the client library automatically computes a hash on the
  // client-side to verify data integrity during transmission.
  StatusOr<gcs::ObjectMetadata> metadata = client.UploadFile(
      file_name, bucket_name, object_name, gcs::IfGenerationMatch(0));
  if (!metadata) throw std::move(metadata).status();

  std::cout << "Uploaded " << file_name << " to object " << metadata->name()
            << " in bucket " << metadata->bucket()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

מידע נוסף מופיע במאמרי העזרה של Cloud Storage C# API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 


using Google.Cloud.Storage.V1;
using System;
using System.IO;

public class UploadFileSample
{
    public void UploadFile(
        string bucketName = "your-unique-bucket-name",
        string localPath = "my-local-path/my-file-name",
        string objectName = "my-file-name")
    {
        var storage = StorageClient.Create();
        using var fileStream = File.OpenRead(localPath);
        storage.UploadObject(bucketName, objectName, null, fileStream);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Go API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

import (
	"context"
	"fmt"
	"io"
	"os"
	"time"

	"cloud.google.com/go/storage"
)

// uploadFile uploads an object.
func uploadFile(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	// Open local file.
	f, err := os.Open("notes.txt")
	if err != nil {
		return fmt.Errorf("os.Open: %w", err)
	}
	defer f.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer cancel()

	o := client.Bucket(bucket).Object(object)

	// Optional: set a generation-match precondition to avoid potential race
	// conditions and data corruptions. The request to upload is aborted if the
	// object's generation number does not match your precondition.
	// For an object that does not yet exist, set the DoesNotExist precondition.
	o = o.If(storage.Conditions{DoesNotExist: true})
	// If the live object already exists in your bucket, set instead a
	// generation-match precondition using the live object's generation number.
	// attrs, err := o.Attrs(ctx)
	// if err != nil {
	// 	return fmt.Errorf("object.Attrs: %w", err)
	// }
	// o = o.If(storage.Conditions{GenerationMatch: attrs.Generation})

	// Upload an object with storage.Writer.
	wc := o.NewWriter(ctx)
	if _, err = io.Copy(wc, f); err != nil {
		return fmt.Errorf("io.Copy: %w", err)
	}
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %w", err)
	}
	fmt.Fprintf(w, "Blob %v uploaded.\n", object)
	return nil
}

Java

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Java API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 


import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.IOException;
import java.nio.file.Paths;

public class UploadObject {
  public static void uploadObject(
      String projectId, String bucketName, String objectName, String filePath) throws IOException {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of your GCS object
    // String objectName = "your-object-name";

    // The path to your file to upload
    // String filePath = "path/to/your/file"

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();

    // Optional: set a generation-match precondition to avoid potential race
    // conditions and data corruptions. The request returns a 412 error if the
    // preconditions are not met.
    Storage.BlobWriteOption precondition;
    if (storage.get(bucketName, objectName) == null) {
      // For a target object that does not yet exist, set the DoesNotExist precondition.
      // This will cause the request to fail if the object is created before the request runs.
      precondition = Storage.BlobWriteOption.doesNotExist();
    } else {
      // If the destination already exists in your bucket, instead set a generation-match
      // precondition. This will cause the request to fail if the existing object's generation
      // changes before the request runs.
      precondition =
          Storage.BlobWriteOption.generationMatch(
              storage.get(bucketName, objectName).getGeneration());
    }
    storage.createFrom(blobInfo, Paths.get(filePath), precondition);

    System.out.println(
        "File " + filePath + " uploaded to bucket " + bucketName + " as " + objectName);
  }
}

Node.js

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Node.js API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The path to your file to upload
// const filePath = 'path/to/your/file';

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function uploadFile() {
  const options = {
    destination: destFileName,
    // Optional:
    // Set a generation-match precondition to avoid potential race conditions
    // and data corruptions. The request to upload is aborted if the object's
    // generation number does not match your precondition. For a destination
    // object that does not yet exist, set the ifGenerationMatch precondition to 0
    // If the destination object already exists in your bucket, set instead a
    // generation-match precondition using its generation number.
    preconditionOpts: {ifGenerationMatch: generationMatchPrecondition},
  };

  await storage.bucket(bucketName).upload(filePath, options);
  console.log(`${filePath} uploaded to ${bucketName}`);
}

uploadFile().catch(console.error);

PHP

מידע נוסף מופיע במאמרי העזרה של Cloud Storage PHP API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $source The path to the file to upload.
 *        (e.g. '/path/to/your/file')
 */
function upload_object(string $bucketName, string $objectName, string $source): void
{
    $storage = new StorageClient();
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

Python

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Python API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"
    # The path to your file to upload
    # source_file_name = "local/path/to/file"
    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    # Optional: set a generation-match precondition to avoid potential race conditions
    # and data corruptions. The request to upload is aborted if the object's
    # generation number does not match your precondition. For a destination
    # object that does not yet exist, set the if_generation_match precondition to 0.
    # If the destination object already exists in your bucket, set instead a
    # generation-match precondition using its generation number.
    generation_match_precondition = 0

    blob.upload_from_filename(source_file_name, if_generation_match=generation_match_precondition)

    print(
        f"File {source_file_name} uploaded to {destination_blob_name}."
    )

Ruby

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Ruby API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

def upload_file bucket_name:, local_file_path:, file_name: nil
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The path to your file to upload
  # local_file_path = "/local/path/to/file.txt"

  # The ID of your GCS object
  # file_name = "your-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name, skip_lookup: true

  file = bucket.create_file local_file_path, file_name

  puts "Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_name}"
end

‫API בארכיטקטורת REST

‫API בפורמט JSON

  1. מקבלים אסימון גישה להרשאה מ-OAuth 2.0 Playground. מגדירים את ה-Playground לשימוש בפרטי הכניסה שלכם ב-OAuth. הוראות מפורטות מופיעות במאמר אימות API.

  2. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט JSON עם בקשת אובייקט POST. בשביל דף האינדקס של www.example.com:

    curl -X POST --data-binary @index.html \
  -H "Content-Type: text/html" \
  -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
  "https://storage.googleapis.com/upload/storage/v1/b/www.example.com/o?uploadType=media&name=index.html"

‫API בפורמט XML

  1. מקבלים אסימון גישה להרשאה מ-OAuth 2.0 Playground. מגדירים את ה-Playground לשימוש בפרטי הכניסה שלכם ב-OAuth. הוראות מפורטות מופיעות במאמר אימות API.

  2. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט XML עם בקשת אובייקט PUT: בשביל דף האינדקס של www.example.com:

    curl -X PUT --data-binary @index.html \
  -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
  -H "Content-Type: text/html" \
  "https://storage.googleapis.com/www.example.com/index.html"

שיתוף הקבצים

כדי להגדיר את כל האובייקטים בקטגוריה כקריאים לכולם באינטרנט הציבורי:

המסוף

  1. במסוף Google Cloud, נכנסים לדף Buckets ב-Cloud Storage.

    כניסה לדף Buckets

  2. ברשימת הקטגוריות, לוחצים על שם הקטגוריה שרוצים להגדיר כציבורית.

  3. לוחצים על הכרטיסייה Permissions בחלק העליון של הדף.

  4. אם בחלונית Public access כתוב Not public, לוחצים על הלחצן Remove public access Prevention, ואז לוחצים על Confirm בתיבת הדו-שיח שמופיעה.

  5. לוחצים על הלחצן Grant access.

    תיבת הדו-שיח Add principals מופיעה.

  6. בשדה New Principals, מזינים allUsers.

  7. בתפריט הנפתח Select a role, בוחרים את תפריט המשנה Cloud Storage, ולוחצים על האפשרות Storage Object Viewer.

  8. לוחצים על Save.

  9. לוחצים על Allow Public Access.

אחרי אישור השיתוף באופן ציבורי, מופיע סמל קישור לכל אובייקט בעמודה public access. אפשר ללחוץ על הסמל הזה כדי לקבל את כתובת ה-URL של האובייקט.

שורת הפקודה

gcloud

משתמשים בפקודה buckets add-iam-policy-binding:

gcloud storage buckets add-iam-policy-binding gs://www.example.com --member=allUsers --role=roles/storage.objectViewer

gsutil

משתמשים בפקודה gsutil iam ch:

gsutil iam ch allUsers:objectViewer gs://www.example.com

ספריות לקוח

C++

מידע נוסף מופיע במאמרי העזרה של Cloud Storage C++ API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  auto current_policy = client.GetNativeBucketIamPolicy(
      bucket_name, gcs::RequestedPolicyVersion(3));
  if (!current_policy) throw std::move(current_policy).status();

  current_policy->set_version(3);
  current_policy->bindings().emplace_back(
      gcs::NativeIamBinding("roles/storage.objectViewer", {"allUsers"}));

  auto updated =
      client.SetNativeBucketIamPolicy(bucket_name, *current_policy);
  if (!updated) throw std::move(updated).status();

  std::cout << "Policy successfully updated: " << *updated << "\n";
}

C#

מידע נוסף מופיע במאמרי העזרה של Cloud Storage C# API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;
using System.Collections.Generic;

public class MakeBucketPublicSample
{
    public void MakeBucketPublic(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();

        Policy policy = storage.GetBucketIamPolicy(bucketName);

        policy.Bindings.Add(new Policy.BindingsData
        {
            Role = "roles/storage.objectViewer",
            Members = new List<string> { "allUsers" }
        });

        storage.SetBucketIamPolicy(bucketName, policy);
        Console.WriteLine(bucketName + " is now public ");
    }
}

Go

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Go API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/iam"
	"cloud.google.com/go/storage"
	iampb "google.golang.org/genproto/googleapis/iam/v1"
)

// setBucketPublicIAM makes all objects in a bucket publicly readable.
func setBucketPublicIAM(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	policy, err := client.Bucket(bucketName).IAM().V3().Policy(ctx)
	if err != nil {
		return fmt.Errorf("Bucket(%q).IAM().V3().Policy: %w", bucketName, err)
	}
	role := "roles/storage.objectViewer"
	policy.Bindings = append(policy.Bindings, &iampb.Binding{
		Role:    role,
		Members: []string{iam.AllUsers},
	})
	if err := client.Bucket(bucketName).IAM().V3().SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("Bucket(%q).IAM().SetPolicy: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Bucket %v is now publicly readable\n", bucketName)
	return nil
}

Java

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Java API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import com.google.cloud.storage.StorageRoles;

public class MakeBucketPublic {
  public static void makeBucketPublic(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Policy originalPolicy = storage.getIamPolicy(bucketName);
    storage.setIamPolicy(
        bucketName,
        originalPolicy
            .toBuilder()
            .addIdentity(StorageRoles.objectViewer(), Identity.allUsers()) // All users can view
            .build());

    System.out.println("Bucket " + bucketName + " is now publicly readable");
  }
}

Node.js

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Node.js API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function makeBucketPublic() {
  await storage.bucket(bucketName).makePublic();

  console.log(`Bucket ${bucketName} is now publicly readable`);
}

makeBucketPublic().catch(console.error);

PHP

מידע נוסף מופיע במאמרי העזרה של Cloud Storage PHP API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

use Google\Cloud\Storage\StorageClient;

/**
 * Update the specified bucket's IAM configuration to make it publicly accessible.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function set_bucket_public_iam(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $policy = $bucket->iam()->policy(['requestedPolicyVersion' => 3]);
    $policy['version'] = 3;

    $role = 'roles/storage.objectViewer';
    $members = ['allUsers'];

    $policy['bindings'][] = [
        'role' => $role,
        'members' => $members
    ];

    $bucket->iam()->setPolicy($policy);

    printf('Bucket %s is now public', $bucketName);
}

Python

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Python API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

from typing import List

from google.cloud import storage

def set_bucket_public_iam(
    bucket_name: str = "your-bucket-name",
    members: List[str] = ["allUsers"],
):
    """Set a public IAM Policy to bucket"""
    # bucket_name = "your-bucket-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    policy = bucket.get_iam_policy(requested_policy_version=3)
    policy.bindings.append(
        {"role": "roles/storage.objectViewer", "members": members}
    )

    bucket.set_iam_policy(policy)

    print(f"Bucket {bucket.name} is now publicly readable")

Ruby

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Ruby API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

def set_bucket_public_iam bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name

  bucket.policy do |p|
    p.add "roles/storage.objectViewer", "allUsers"
  end

  puts "Bucket #{bucket_name} is now publicly readable"
end

‫API בארכיטקטורת REST

‫API בפורמט JSON

  1. מקבלים אסימון גישה להרשאה מ-OAuth 2.0 Playground. מגדירים את ה-Playground לשימוש בפרטי הכניסה שלכם ב-OAuth. הוראות מפורטות מופיעות במאמר אימות API.

  2. יוצרים קובץ JSON שמכיל את הפרטים הבאים:

    {
  "bindings":[
    {
      "role": "roles/storage.objectViewer",
      "members":["allUsers"]
    }
  ]
}

  3. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט JSON באמצעות בקשת קטגוריה PUT:

    curl -X PUT --data-binary @JSON_FILE_NAME \
  -H "Authorization: Bearer OAUTH2_TOKEN" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"

    כאשר:

    • ‫JSON_FILE_NAME הוא הנתיב לקובץ ה-JSON שיצרתם בשלב 2.
    • ‫OAUTH2_TOKEN הוא אסימון הגישה שיצרתם בשלב 1.
    • ‫BUCKET_NAME הוא שם הקטגוריה, שאת האובייקטים שלה רוצים להגדיר כציבוריים. לדוגמה, my-bucket.

‫API בפורמט XML

ב-API בפורמט XML אין תמיכה להגדרת כל האובייקטים בקטגוריה כקריאים לציבור. במקום זאת, אפשר להשתמש במסוף Google Cloud או ב-gcloud storage.

אפשר להגדיר קבוצות של אובייקטים בקטגוריה כנגישים באופן ציבורי, אבל באופן כללי, קל ומהיר יותר להנגיש את כל הקבצים בקטגוריה באופן ציבורי.

המבקרים יקבלו קוד תגובה http 403 כשהם מבקשים את כתובת ה-URL של קובץ שאינו ציבורי או לא קיים. בקטע הבא מוסבר איך להוסיף דף שגיאה שמשתמש בקוד התגובה http 404.

מומלץ: הקצאת דפים מיוחדים

אפשר להקצות סיומת של דף אינדקס, שנשלטת על ידי המאפיין MainPageSuffix, וגם דף שגיאה בהתאמה אישית שנשלט על ידי המאפיין NotFoundPage. לא חובה להקצות אחד מהם, אבל בלי דף אינדקס, לא יוצג כלום למשתמשים כשהם ניגשים לאתר ברמה העליונה, לדוגמה http://www.example.com. למידע נוסף, ראו דוגמאות להגדרות של אתר.

בדוגמה הבאה, הערך MainPageSuffix מוגדר ל-index.html ו-NotFoundPage מוגדר ל-404.html:

המסוף

  1. במסוף Google Cloud, נכנסים לדף Buckets ב-Cloud Storage.

    כניסה לדף Buckets

  2. מוצאים ברשימת הקטגוריות את הקטגוריה שיצרתם.

  3. לוחצים על התפריט Bucket overflow () שמשויך לקטגוריה ובוחרים Edit website configuration.

  4. בתיבת הדו-שיח של הגדרת האתר, מציינים את הדף הראשי ואת דף השגיאה.

  5. לוחצים על Save.

שורת הפקודה

gcloud

משתמשים בפקודה buckets update עם הדגלים --web-main-page-suffix ו---web-error-page:

gcloud storage buckets update gs://www.example.com --web-main-page-suffix=index.html --web-error-page=404.html

אם הפעולה הצליחה, הפקודה תחזיר:

Updating gs://www.example.com/...
  Completed 1

gsutil

משתמשים בפקודה gsutil web set כדי להגדיר את המאפיין MainPageSuffix עם הדגל -m ואת NotFoundPage עם הדגל -e:

gsutil web set -m index.html -e 404.html gs://www.example.com

אם הפעולה הצליחה, הפקודה תחזיר:

Setting website config on gs://www.example.com/...

ספריות לקוח

C++

מידע נוסף מופיע במאמרי העזרה של Cloud Storage C++ API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& main_page_suffix, std::string const& not_found_page) {
  StatusOr<gcs::BucketMetadata> original =
      client.GetBucketMetadata(bucket_name);

  if (!original) throw std::move(original).status();
  StatusOr<gcs::BucketMetadata> patched = client.PatchBucket(
      bucket_name,
      gcs::BucketMetadataPatchBuilder().SetWebsite(
          gcs::BucketWebsite{main_page_suffix, not_found_page}),
      gcs::IfMetagenerationMatch(original->metageneration()));
  if (!patched) throw std::move(patched).status();

  if (!patched->has_website()) {
    std::cout << "Static website configuration is not set for bucket "
              << patched->name() << "\n";
    return;
  }

  std::cout << "Static website configuration successfully set for bucket "
            << patched->name() << "\nNew main page suffix is: "
            << patched->website().main_page_suffix
            << "\nNew not found page is: "
            << patched->website().not_found_page << "\n";
}

C#

מידע נוסף מופיע במאמרי העזרה של Cloud Storage C# API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class BucketWebsiteConfigurationSample
{
    public Bucket BucketWebsiteConfiguration(
        string bucketName = "your-bucket-name",
        string mainPageSuffix = "index.html",
        string notFoundPage = "404.html")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);

        if (bucket.Website == null)
        {
            bucket.Website = new Bucket.WebsiteData();
        }
        bucket.Website.MainPageSuffix = mainPageSuffix;
        bucket.Website.NotFoundPage = notFoundPage;

        bucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Static website bucket {bucketName} is set up to use {mainPageSuffix} as the index page and {notFoundPage} as the 404 not found page.");
        return bucket;
    }
}

Go

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Go API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// setBucketWebsiteInfo sets website configuration on a bucket.
func setBucketWebsiteInfo(w io.Writer, bucketName, indexPage, notFoundPage string) error {
	// bucketName := "www.example.com"
	// indexPage := "index.html"
	// notFoundPage := "404.html"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Website: &storage.BucketWebsite{
			MainPageSuffix: indexPage,
			NotFoundPage:   notFoundPage,
		},
	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Static website bucket %v is set up to use %v as the index page and %v as the 404 page\n", bucketName, indexPage, notFoundPage)
	return nil
}

Java

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Java API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class SetBucketWebsiteInfo {
  public static void setBucketWesbiteInfo(
      String projectId, String bucketName, String indexPage, String notFoundPage) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your static website bucket
    // String bucketName = "www.example.com";

    // The index page for a static website bucket
    // String indexPage = "index.html";

    // The 404 page for a static website bucket
    // String notFoundPage = "404.html";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);
    bucket.toBuilder().setIndexPage(indexPage).setNotFoundPage(notFoundPage).build().update();

    System.out.println(
        "Static website bucket "
            + bucketName
            + " is set up to use "
            + indexPage
            + " as the index page and "
            + notFoundPage
            + " as the 404 page");
  }
}

Node.js

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Node.js API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of the main page
// const mainPageSuffix = 'http://example.com';

// The Name of a 404 page
// const notFoundPage = 'http://example.com/404.html';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function addBucketWebsiteConfiguration() {
  await storage.bucket(bucketName).setMetadata({
    website: {
      mainPageSuffix,
      notFoundPage,
    },
  });

  console.log(
    `Static website bucket ${bucketName} is set up to use ${mainPageSuffix} as the index page and ${notFoundPage} as the 404 page`
  );
}

addBucketWebsiteConfiguration().catch(console.error);

PHP

מידע נוסף מופיע במאמרי העזרה של Cloud Storage PHP API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

use Google\Cloud\Storage\StorageClient;

/**
 * Update the given bucket's website configuration.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $indexPageObject the name of an object in the bucket to use as
 *        (e.g. 'index.html')
 *     an index page for a static website bucket.
 * @param string $notFoundPageObject the name of an object in the bucket to use
 *        (e.g. '404.html')
 *     as the 404 Not Found page.
 */
function define_bucket_website_configuration(string $bucketName, string $indexPageObject, string $notFoundPageObject): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $bucket->update([
        'website' => [
            'mainPageSuffix' => $indexPageObject,
            'notFoundPage' => $notFoundPageObject
        ]
    ]);

    printf(
        'Static website bucket %s is set up to use %s as the index page and %s as the 404 page.',
        $bucketName,
        $indexPageObject,
        $notFoundPageObject
    );
}

Python

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Python API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

from google.cloud import storage

def define_bucket_website_configuration(bucket_name, main_page_suffix, not_found_page):
    """Configure website-related properties of bucket"""
    # bucket_name = "your-bucket-name"
    # main_page_suffix = "index.html"
    # not_found_page = "404.html"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    bucket.configure_website(main_page_suffix, not_found_page)
    bucket.patch()

    print(
        "Static website bucket {} is set up to use {} as the index page and {} as the 404 page".format(
            bucket.name, main_page_suffix, not_found_page
        )
    )
    return bucket

Ruby

מידע נוסף מופיע במאמרי העזרה של Cloud Storage Ruby API.

כדי לבצע אימות ב-Cloud Storage, צריך להגדיר את Application Default Credentials. מידע נוסף מופיע במאמר הגדרת אימות לסביבת פיתוח מקומית. 

def define_bucket_website_configuration bucket_name:, main_page_suffix:, not_found_page:
  # The ID of your static website bucket
  # bucket_name = "www.example.com"

  # The index page for a static website bucket
  # main_page_suffix = "index.html"

  # The 404 page for a static website bucket
  # not_found_page = "404.html"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name

  bucket.update do |b|
    b.website_main = main_page_suffix
    b.website_404 = not_found_page
  end

  puts "Static website bucket #{bucket_name} is set up to use #{main_page_suffix} as the index page and " \
       "#{not_found_page} as the 404 page"
end

‫API בארכיטקטורת REST

‫API בפורמט JSON

  1. מקבלים אסימון גישה להרשאה מ-OAuth 2.0 Playground. מגדירים את ה-Playground לשימוש בפרטי הכניסה שלכם ב-OAuth. הוראות מפורטות מופיעות במאמר אימות API.

  2. יוצרים קובץ JSON שמגדיר את המאפיינים mainPageSuffix ו-notFoundPage באובייקט website לדפים הרצויים:

    {
  "website":{
    "mainPageSuffix": "index.html",
    "notFoundPage": "404.html"
  }
}

  3. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט JSON באמצעות בקשת קטגוריה PATCH. בשביל www.example.com:

    curl -X PATCH --data-binary @web-config.json \
  -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/www.example.com"

‫API בפורמט XML

  1. מקבלים אסימון גישה להרשאה מ-OAuth 2.0 Playground. מגדירים את ה-Playground לשימוש בפרטי הכניסה שלכם ב-OAuth. הוראות מפורטות מופיעות במאמר אימות API.

  2. יוצרים קובץ XML שמגדיר את הרכיבים MainPageSuffix ו-NotFoundPage ברכיב WebsiteConfiguration לדפים הרצויים:

    <WebsiteConfiguration>
  <MainPageSuffix>index.html</MainPageSuffix>
  <NotFoundPage>404.html</NotFoundPage>
</WebsiteConfiguration>

  3. משתמשים ב-cURL כדי לשלוח קריאה ל-API בפורמט XML באמצעות בקשת קטגוריה PUT ופרמטר מחרוזת שאילתה websiteConfig. בשביל www.example.com:

    curl -X PUT --data-binary @web-config.xml \
  -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
  https://storage.googleapis.com/www.example.com?websiteConfig

בדיקת האתר

כדי לוודא שהתוכן מוצג מהקטגוריה, מבקשים את שם הדומיין בדפדפן. אפשר לעשות זאת באמצעות נתיב לאובייקט או באמצעות שם הדומיין עצמו, אם מוגדר המאפיין MainPageSuffix.

לדוגמה, אם יש אובייקט בשם test.html ששמור בקטגוריה בשם www.example.com, צריך לעבור אל www.example.com/test.html בדפדפן כדי לבדוק אם אפשר לגשת אליו.

הסרת המשאבים

אחרי שמסיימים את המדריך, אפשר למחוק את המשאבים שנוצרו, כדי שהם יפסיקו להשתמש במכסה ולצבור חיובים. בסעיפים הבאים מוסבר איך למחוק או להשבית את המשאבים האלו.

מחיקת הפרויקט

הדרך הקלה ביותר לבטל את החיוב היא למחוק את הפרויקט שיצרתם בשביל המדריך.

כדי למחוק את הפרויקט:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

המאמרים הבאים