Vertex AI: TensorFlow ile Çok Çalışanlı Eğitim ve Öğrenimi Aktarma

1. Genel Bakış

Bu laboratuvarda, TensorFlow modeli için çok çalışanlı bir eğitim işi çalıştırmak amacıyla Vertex AI'ı kullanacaksınız.

Öğrenecekleriniz

Öğrenecekleriniz:

• Çok çalışanlı eğitim için eğitim uygulama kodunu değiştirme
• Vertex AI kullanıcı arayüzünden çok çalışanlı eğitim işi yapılandırma ve başlatma
• Vertex SDK ile çok çalışanlı eğitim işi yapılandırma ve başlatma

Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 5 ABD dolarıdır.

2. Vertex AI'a giriş

Bu laboratuvarda, Google Cloud'daki en yeni AI ürün teklifi kullanılmaktadır. Vertex AI, Google Cloud'daki makine öğrenimi tekliflerini sorunsuz bir geliştirme deneyimiyle entegre eder. Önceden, AutoML ve özel modellerle eğitilen modellere ayrı hizmetler üzerinden erişilebiliyordu. Yeni teklif, her ikisi de tek bir API'de ve diğer yeni ürünlerle birleştirilir. Dilerseniz mevcut projeleri Vertex AI'a taşıyabilirsiniz. Geri bildiriminiz varsa lütfen destek sayfasını inceleyin.

Vertex AI, uçtan uca makine öğrenimi iş akışlarını destekleyen birçok farklı ürün içerir. Bu laboratuvarda, aşağıda vurgulanan ürünlere odaklanılmaktadır: training ve Workbench

3. Kullanım Alanına Genel Bakış

Bu laboratuvarda, TensorFlow Veri Kümeleri'ndeki mantık veri kümesinde bir görüntü sınıflandırma modeli eğitmek için aktarımla öğrenme özelliğini kullanacaksınız. Kullanacağınız mimari, Imagenet veri kümesi üzerinde önceden eğitilmiş tf.keras.applications kitaplığındaki bir ResNet50 modelidir.

Neden Dağıtılmış Eğitim?

Tek bir GPU'nuz varsa TensorFlow, herhangi bir ek işlem yapmanıza gerek kalmadan model eğitimini hızlandırmak için bu hızlandırıcıyı kullanır. Ancak, tek bir makinede veya her biri potansiyel olarak birden fazla GPU'ya sahip olan birden fazla makinede birden fazla GPU kullanarak ek artış elde etmek istiyorsanız TensorFlow'un birden fazla cihazda işlem yapmaya yönelik kitaplığı olan tf.distribute kullanmanız gerekir. Cihaz, TensorFlow'un işlem yapabileceği bazı makinelerdeki CPU veya hızlandırıcı (GPU veya TPU gibi) anlamına gelir.

Dağıtılmış eğitime başlamanın en basit yolu, birden fazla GPU cihazına sahip tek bir makinedir. tf.distribute modülündeki bir TensorFlow dağıtım stratejisi, tüm GPU'lar genelinde veri dağılımını ve gradyan güncellemelerinin koordinasyonunu yönetir. Tek ana makine eğitiminde uzmanlaştıysanız ve daha da ölçeklendirmek istiyorsanız kümenize birden fazla makine eklemek performansın daha da artmasını sağlayabilir. Yalnızca CPU'lu veya her biri en az bir GPU'ya sahip olan makine kümelerinden yararlanabilirsiniz. Bu laboratuvarda, ikinci durum ele alınıp TensorFlow modelinin eğitimini Vertex AI'daki birden fazla makineye dağıtmak için MultiWorkerMirroredStrategy özelliğinin nasıl kullanılacağı gösterilmektedir.

MultiWorkerMirroredStrategy, yalnızca birkaç kod değişikliğiyle kullanabileceğiniz eşzamanlı bir veri paralelliği stratejisidir. Kümenizdeki her cihazda modelin bir kopyası oluşturulur. Sonraki gradyan güncellemeleri eşzamanlı bir şekilde gerçekleşir. Bu, her çalışan cihazının, giriş verilerinin farklı bir dilimdeki modelde ileri ve geri hareketlerini hesapladığı anlamına gelir. Bu dilimlerin her birinden hesaplanan renk geçişleri, daha sonra bir makinedeki tüm cihazlar ve kümedeki tüm makineler genelinde toplanır ve "tamamen azaltma" adı verilen bir işlemde azaltılır (genellikle ortalama). Daha sonra optimize edici, bu azaltılmış renk geçişleriyle parametre güncellemelerini gerçekleştirir ve böylece cihazların senkronize olmasını sağlar. TensorFlow ile dağıtılmış eğitim hakkında daha fazla bilgi edinmek için aşağıdaki videoya göz atın:

4. Ortamınızı ayarlama

Bu codelab'i çalıştırmak için faturalandırmanın etkin olduğu bir Google Cloud Platform projesine ihtiyacınız var. Proje oluşturmak için buradaki talimatları uygulayın.

1. Adım: Compute Engine API'yi etkinleştirin

Compute Engine'e gidin ve zaten etkinleştirilmemişse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için buna ihtiyacınız olacaktır.

2. Adım: Container Registry API'yi etkinleştirin

Container Registry'ye gidin ve henüz yapmadıysanız Etkinleştir'i seçin. Özel eğitim işiniz için bir container oluşturmak üzere bunu kullanacaksınız.

3. adım: Vertex AI API'yi etkinleştirin

Cloud Console'un Vertex AI bölümüne gidip Enable Vertex AI API'yi (Vertex AI API'yi etkinleştir) tıklayın.

4. Adım: Vertex AI Workbench örneği oluşturun

Cloud Console'un Vertex AI bölümünde Workbench'i tıklayın:

Henüz etkinleştirilmemişse Notebooks API'yi etkinleştirin.

Etkinleştirdikten sonra YÖNETİLEN NOT KİTAPLARI'nı tıklayın:

Ardından YENİ NOT DEFTERİ'ni seçin.

Not defterinize bir ad verin ve Gelişmiş Ayarlar'ı tıklayın.

Gelişmiş Ayarlar altından boşta kalma özelliğini etkinleştirin ve dakika sayısını 60 olarak ayarlayın. Bu sayede not defteriniz kullanılmadığında otomatik olarak kapatılır, böylece gereksiz maliyetlere neden olmazsınız.

Güvenlik bölümünde "Terminali etkinleştir"i seçin Etkin değilse.

Diğer gelişmiş ayarların tümünü olduğu gibi bırakabilirsiniz.

Ardından Oluştur'u tıklayın. Örneğin temel hazırlığının yapılması birkaç dakika sürer.

Örnek oluşturulduktan sonra JupyterLab'i aç'ı seçin.

Yeni bir örneği ilk kez kullandığınızda kimliğinizi doğrulamanız istenir. Bu işlemi yapmak için kullanıcı arayüzündeki adımları uygulayın.

5. Eğitim uygulaması kodunu container mimarisine alın

Eğitim uygulama kodunuzu bir Docker container'ına yerleştirip bu container'ı Google Container Registry'ye aktararak bu eğitim işini Vertex'e göndereceksiniz. Bu yaklaşımı kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebilirsiniz.

Başlatıcı menüsünden başlamak için not defteri örneğinizde bir Terminal penceresi açın:

cassava adında yeni bir dizin oluşturun ve cd'ye ekleyin:

mkdir cassava
cd cassava

1. Adım: Dockerfile oluşturun

Kodunuzu container mimarisine almanın ilk adımı bir Dockerfile oluşturmaktır. Dockerfile'a görüntüyü çalıştırmak için gereken tüm komutları eklersiniz. Gerekli tüm kitaplıkları yükler ve eğitim kodu için giriş noktasını ayarlar.

Terminal'inizden boş bir Dockerfile oluşturun:

touch Dockerfile

Dockerfile'ı açın ve aşağıdakini bu dosyaya kopyalayın:

FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-7

WORKDIR /

# Copies the trainer code to the docker image.
COPY trainer /trainer

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]

Bu Dockerfile, Deep Learning Container TensorFlow Enterprise 2.7 GPU Docker görüntüsünü kullanır. Google Cloud'daki Deep Learning Containers, yaygın olarak kullanılan birçok makine öğrenimi ve veri bilimi çerçevesi önceden yüklenmiş olarak sunulur. Bu görüntü indirildikten sonra bu Dockerfile, eğitim kodu için giriş noktasını ayarlar. Bu dosyaları henüz oluşturmadınız. Bir sonraki adımda modeli eğitmek ve ayarlamak için kodu ekleyeceksiniz.

2. Adım: Cloud Storage paketi oluşturun

Bu eğitim işinde, eğitilen TensorFlow modelini bir Cloud Storage Paketine aktaracaksınız. Terminalinizde projeniz için bir env değişkeni tanımlamak üzere aşağıdaki komutu çalıştırın. your-cloud-project kısmına projenizin kimliğini girdiğinizden emin olun:

Terminalinizde gcloud config list --format 'value(core.project)' komutunu çalıştırarak proje kimliğinizi alabilirsiniz

PROJECT_ID='your-cloud-project'

Ardından projenizde yeni bir paket oluşturmak için aşağıdaki komutu Terminal'de çalıştırın.

BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET

3. Adım: Model eğitim kodunu ekleyin

Terminal'inizden aşağıdaki komutu çalıştırarak eğitim kodu için bir dizin ve kodu ekleyeceğiniz Python dosyası oluşturun:

mkdir trainer
touch trainer/task.py

Artık cassava/ dizininizde aşağıdakilerin olması gerekir:

+ Dockerfile
+ trainer/
    + task.py

Sonra, az önce oluşturduğunuz task.py dosyasını açın ve aşağıdaki kodu kopyalayın. {your-gcs-bucket} kısmını az önce oluşturduğunuz Cloud Storage paketinin adıyla değiştirmeniz gerekir.

import tensorflow as tf
import tensorflow_datasets as tfds
import os


PER_REPLICA_BATCH_SIZE = 64
EPOCHS = 2

# TODO: replace {your-gcs-bucket} with the name of the Storage bucket you created earlier
BUCKET = 'gs://{your-gcs-bucket}/mwms'

def preprocess_data(image, label):
  '''Resizes and scales images.'''

  image = tf.image.resize(image, (300,300))
  return tf.cast(image, tf.float32) / 255., label


def create_dataset(batch_size):
  '''Loads Cassava dataset and preprocesses data.'''

  data, info = tfds.load(name='cassava', as_supervised=True, with_info=True)
  number_of_classes = info.features['label'].num_classes
  train_data = data['train'].map(preprocess_data,
                                 num_parallel_calls=tf.data.experimental.AUTOTUNE)
  train_data  = train_data.shuffle(1000)
  train_data  = train_data.batch(batch_size)
  train_data  = train_data.prefetch(tf.data.experimental.AUTOTUNE)

  # Set AutoShardPolicy
  options = tf.data.Options()
  options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.DATA
  train_data = train_data.with_options(options)

  return train_data, number_of_classes


def create_model(number_of_classes):
  '''Creates and compiles pretrained ResNet50 model.'''

  base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False)
  x = base_model.output
  x = tf.keras.layers.GlobalAveragePooling2D()(x)
  x = tf.keras.layers.Dense(1016, activation='relu')(x)
  predictions = tf.keras.layers.Dense(number_of_classes, activation='softmax')(x)
  model = tf.keras.Model(inputs=base_model.input, outputs=predictions)

  model.compile(
      loss='sparse_categorical_crossentropy',
      optimizer=tf.keras.optimizers.Adam(0.0001),
      metrics=['accuracy'])

  return model


def _is_chief(task_type, task_id):
  '''Helper function. Determines if machine is chief.'''

  return task_type == 'chief'


def _get_temp_dir(dirpath, task_id):
  '''Helper function. Gets temporary directory for saving model.'''

  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir


def write_filepath(filepath, task_type, task_id):
  '''Helper function. Gets filepath to save model.'''

  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)


def main():
  # Create strategy
  strategy = tf.distribute.MultiWorkerMirroredStrategy()

  # Get data
  global_batch_size = PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync
  train_data, number_of_classes = create_dataset(global_batch_size)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model(number_of_classes)

  model.fit(train_data, epochs=EPOCHS)

  # Determine type and task of the machine from
  # the strategy cluster resolver
  task_type, task_id = (strategy.cluster_resolver.task_type,
                        strategy.cluster_resolver.task_id)

  # Based on the type and task, write to the desired model path
  write_model_path = write_filepath(BUCKET, task_type, task_id)
  model.save(write_model_path)

if __name__ == "__main__":
    main()

Kapsayıcıyı derlemeden önce, tf.distribute.Strategy API'den MultiWorkerMirroredStrategy kullanan koda daha yakından bakalım.

MultiWorkerMirroredStrategy, eğitimin bir kümedeki her biri potansiyel olarak birden fazla GPU'ya sahip birden fazla makineye dağıtılması için tasarlanmıştır. Eğitimi tek bir cihazda birden fazla GPU'ya dağıtmak istiyorsanız MirroredStrategy sayfasını inceleyin.

Kodda, kodunuzun MultiWorkerMirroredStrategy ile çalışması için gereken birkaç bileşen vardır.

1. Verilerin parçalanması gerekir. Diğer bir deyişle, her çalışana tüm veri kümesinin bir alt kümesi atanır. Bu nedenle, her adımda her çalışan tarafından, örtüşmeyen veri kümesi öğelerinin genel bir toplu boyutu işlenir. Bu parçalama işlemi, FILE veya DATA olarak ayarlanabilen tf.data.experimental.AutoShardPolicy ile otomatik olarak gerçekleşir. Bu örnekte, Cassava veri kümesi birden fazla dosya olarak indirilmediğinden, create_dataset() işlevi AutoShardPolicy değerini DATA olarak ayarlar. Ancak politikayı DATA olarak ayarlamadıysanız varsayılan AUTO politikası devreye girer ve nihai sonuç aynı olur. MultiWorkerMirroredStrategy ile veri kümesi parçalama hakkında daha fazla bilgi edinebilirsiniz.
2. main() işlevinde MultiWorkerMirroredStrategy nesnesi oluşturulur. Daha sonra, model değişkenlerinizi oluşturma sürecini stratejinin kapsamında sarmalayın. Bu önemli adım, TensorFlow'a hangi değişkenlerin replikalar genelinde yansıtılması gerektiğini bildirir.
3. Grup boyutu num_replicas_in_sync oranında artırılır. Bu, her replikanın her adımda aynı sayıda örneği işlemesini sağlar. TensorFlow'da eşzamanlı veri paralelliği stratejilerini kullanırken grup boyutunu ölçeklendirmek en iyi uygulamadır.
4. Hedefin her çalışan için farklı olması gerektiğinden, çok çalışanlı bir durumda modelinizi kaydetmek biraz daha karmaşıktır. Baş çalışan istenen model dizinine kaydederken diğer çalışanlar modeli geçici dizinlere kaydeder. Birden fazla çalışanın aynı konuma yazmasını önlemek için bu geçici dizinlerin benzersiz olması önemlidir. Tasarruf hep birlikte yürütülebilir. Yani sadece amiri değil, tüm çalışanların da kurtarması gerekir. _is_chief(), _get_temp_dir(), write_filepath() işlevleri ve main() işlevinin tümü, modelin kaydedilmesine yardımcı olan ortak kod içerir.

MultiWorkerMirroredStrategy ürününü farklı bir ortamda kullandıysanız TF_CONFIG ortam değişkenini oluşturmuş olabileceğinizi unutmayın. Vertex AI sizin için otomatik olarak TF_CONFIG ayarlar. Böylece kümenizdeki her makinede bu değişkeni tanımlamanız gerekmez.

4. Adım: Kapsayıcıyı oluşturun

Terminalinizde projeniz için bir env değişkeni tanımlamak üzere aşağıdaki komutu çalıştırın. your-cloud-project kısmına projenizin kimliğini girdiğinizden emin olun:

Terminalinizde gcloud config list --format 'value(core.project)' komutunu çalıştırarak proje kimliğinizi alabilirsiniz

PROJECT_ID='your-cloud-project'

Google Container Registry'deki kapsayıcı görüntünüzün URI'sıyla bir değişken tanımlayın:

IMAGE_URI="gcr.io/$PROJECT_ID/multiworker:cassava"

Docker'ı yapılandırma

gcloud auth configure-docker

Ardından, cassava dizininizin kök dizininden aşağıdaki komutu çalıştırarak container'ı oluşturun:

docker build ./ -t $IMAGE_URI

Son olarak, dosyayı Google Container Registry'ye aktarın:

docker push $IMAGE_URI

Container, Container Registry'ye aktarıldığında artık eğitim işi başlatmaya hazırsınız.

6. Vertex AI'da çok çalışanlı bir eğitim işi çalıştırma

Bu laboratuvarda, Google Container Registry'deki özel bir container aracılığıyla özel eğitim kullanılır. Bununla birlikte, önceden oluşturulmuş container'larla da bir eğitim işi çalıştırabilirsiniz.

Başlamak için Cloud konsolunuzun Vertex bölümündeki Eğitim bölümüne gidin:

1. Adım: Eğitim işini yapılandırın

Eğitim işinizin parametrelerini girmek için Oluştur'u tıklayın.

• Veri Kümesi bölümünde, Yönetilen veri kümesi yok'u seçin.
• Ardından eğitim yönteminiz olarak Özel eğitim (gelişmiş) seçeneğini belirleyin ve Devam'ı tıklayın.
• Model adı için multiworker-cassava değerini (veya modelinizi adlandırmak istediğiniz adı) girin
• Devam et'i tıklayın.

Kapsayıcı ayarları adımında Özel kapsayıcı'yı seçin:

İlk kutuya (Kapsayıcı resmi), önceki bölümde bulunan IMAGE_URI değişkeninizin değerini girin. Kendi proje kimliğinizi içeren gcr.io/your-cloud-project/multiworker:cassava olmalıdır. Diğer alanları boş bırakıp Devam'ı tıklayın.

Devam'ı tekrar tıklayarak Hhyperparameters adımını atlayın.

2. Adım: Compute kümesini yapılandırın

Vertex AI, farklı makine görevi türlerini kapsayan 4 çalışan havuzu sağlar.

Çalışan havuzu 0 birincil, şef, planlayıcı veya "ana" havuz ayarını yapılandırır. MultiWorkerMirroredStrategy ürününde tüm makineler, çalışan olarak tanımlanmıştır. Çalışanlar, bunlar üzerinde çoğaltılan hesaplamanın yürütüldüğü fiziksel makinelerdir. Her makinenin bir çalışan olmasına ek olarak, kontrol noktalarını kaydetme ve TensorBoard'a özet dosyaları yazma gibi ek işler gerektiren bir çalışana ihtiyaç vardır. Bu makine şef olarak bilinir. Yalnızca bir baş çalışan vardır. Bu nedenle 0 olan çalışan havuzu için çalışan sayınız her zaman 1 olur.

İşlem ve fiyatlandırma bölümünde seçili bölgeyi olduğu gibi bırakın ve Çalışan havuzu 0'ı aşağıdaki gibi yapılandırın:

GPU eklemeyi tercih edebilirsiniz. Ancak MultiWorkerMirroredStrategy için kümenizdeki her makinenin aynı sayıda GPU'ya sahip olması gerektiğini unutmayın. GPU eklemek, eğitim işinin maliyetini de artırır.

Çalışan havuzu 1, kümenizin çalışanlarını yapılandırdığınız yerdir.

Çalışan havuzu 1'i aşağıdaki gibi yapılandırın:

Küme artık yalnızca iki CPU'lu makineye sahip olacak şekilde yapılandırılmıştır. Eğitim uygulama kodu çalıştırıldığında MultiWorkerMirroredStrategy, eğitimi her iki makineye de dağıtır.

MultiWorkerMirroredStrategy yalnızca patron ve çalışan görevi türlerine sahiptir. Bu nedenle ek Çalışan Havuzlarının yapılandırılmasına gerek yoktur. Ancak, TensorFlow'un ParameterServerStrategy özelliğini kullanacaksanız parametre sunucularınızı çalışan havuzu 2'de yapılandırırsınız. Kümenize bir değerlendirici eklemek istiyorsanız bu makineyi çalışan havuzu 3'te yapılandırırsınız.

Hiperparametre ayarlama işini başlatmak için Eğitimi başlat'ı tıklayın. Konsolunuzun EĞİTİM HATALARI sekmesinin altında Eğitim bölümünde yeni başlatılan işinizi görürsünüz:

Eğitim işinin tamamlanması yaklaşık 30-35 dakika sürer.

🎉 Tebrikler! 🎉

Vertex AI'ı kullanarak şunları öğrendiniz:

• Özel bir container'da sağlanan eğitim kodu için çok çalışanlı bir eğitim işi başlatın. Bu örnekte bir TensorFlow modeli kullanmıştınız ancak özel veya yerleşik container'lar kullanarak herhangi bir çerçeveyle oluşturulmuş bir modeli eğitebilirsiniz.

Vertex'in farklı bölümleri hakkında daha fazla bilgi edinmek için dokümanlara göz atın.

7. [İsteğe bağlı] Vertex SDK'yı kullanma

Önceki bölümde, eğitim işinin kullanıcı arayüzü üzerinden nasıl başlatılacağı gösteriliyordu. Bu bölümde, Vertex Python API'yi kullanarak eğitim işini göndermenin alternatif bir yolunu göreceksiniz.

Not defteri örneğinize dönün ve Başlatıcı'dan bir TensorFlow 2 not defteri oluşturun:

Vertex AI SDK'sını içe aktarın.

from google.cloud import aiplatform

Çok çalışanlı eğitim işini başlatmak için önce çalışan havuzu özelliklerini tanımlamanız gerekir. Spesifikasyondaki GPU kullanımının tamamen isteğe bağlı olduğunu unutmayın. Önceki bölümde gösterildiği gibi yalnızca CPU kullanılmasını istiyorsanız accelerator_type ve accelerator_count kümelerini kaldırabilirsiniz.

# The spec of the worker pools including machine type and Docker image
# Be sure to replace {YOUR-PROJECT-ID} with your project ID.
worker_pool_specs=[
     {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
        },
        "container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
      },
      {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
        },
        "container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
      }
]

Sonra, bir CustomJob oluşturup çalıştırın. Hazırlık için {YOUR_BUCKET} öğesini projenizde bir paketle değiştirmeniz gerekir. Daha önce oluşturduğunuz paketi kullanabilirsiniz.

# Replace YOUR_BUCKET
my_multiworker_job = aiplatform.CustomJob(display_name='multiworker-cassava-sdk',
                              worker_pool_specs=worker_pool_specs,
                              staging_bucket='gs://{YOUR_BUCKET}')

my_multiworker_job.run()

Konsolunuzun ÖZEL İŞLER sekmesinin altındaki Eğitim bölümünde eğitim işinizi görürsünüz:

8. Temizleme

Not defterini 60 dakika boşta kalma dakikasının sonunda zaman aşımına uğrayacak şekilde yapılandırdığımızdan örneği kapatma konusunda endişelenmemize gerek yoktur. Örneği manuel olarak kapatmak isterseniz konsolun Vertex AI Workbench bölümündeki Durdur düğmesini tıklayın. Not defterini tamamen silmek isterseniz Sil düğmesini tıklayın.

Storage Paketini silmek için Cloud Console'unuzdaki gezinme menüsünü kullanarak Storage'a gidin, paketinizi seçin ve Sil'i tıklayın: