# Google Cloud Storage

Google Cloud Storage में इमेज डेटा स्टोरेज और Roboflow पर अपलोड करते समय आपके पास सामान्यतः दो विकल्प होते हैं: साइन किए गए URL का उपयोग करना या इमेज को लोकली डाउनलोड करके (gsutil CLI के माध्यम से) स्थानीय रूप से अपलोड करना। इन विधियों के बीच चयन आपके डेटा प्रोसेसिंग और प्रबंधन की विशिष्ट आवश्यकताओं पर निर्भर करता है।

* **Signed URLs**: यह विधि विशेष रूप से फायदेमंद है यदि आप इमेज को अपनी लोकल मशीन पर डाउनलोड करने से जुड़े अतिरिक्त कदम और समय से बचना चाहते हैं। एक साइन किए गए URL के साथ, आप Google Cloud Storage से सीधे Roboflow API को इमेज डेटा अपलोड कर सकते हैं बिना इसे लोकली स्टोर किए। इससे प्रोसेसिंग तेज़ होती है और आपके लोकल सिस्टम पर कम लोड आता है।
* **CLI Locally**: कुछ परिदृश्यों में आप पहले इमेज को अपनी लोकल एनवायरनमेंट में डाउनलोड करना पसंद कर सकते हैं। उदाहरण के लिए, यदि आपको इमेजेस को प्रीप्रोसेस करना है या Roboflow पर अपलोड करने से पहले मैन्युअल रूप से चेक करना है, तो लोकल कॉपी होना लाभप्रद होगा।

सही विधि का चयन आपकी विशेष उपयोग-केस आवश्यकताओं पर निर्भर करेगा, जैसे डेटा ट्रांसफर की गति, प्रीप्रोसेसिंग की आवश्यकता, या इमेजेस का मैन्युअल निरीक्षण।

### Google Cloud JSON Key

बकेट के लिए उपयुक्त अनुमतियों के साथ एक सर्विस अकाउंट बनाएं और JSON key फ़ाइल डाउनलोड करें। इस फ़ाइल में आपके एप्लिकेशन को प्रमाणीकरण करने के लिए उपयोग की जाने वाली क्रेडेंशियल्स होंगी।

### Option 1: Upload Via Signed URL:

आप Google Cloud SDK का उपयोग करके Python में अपने Google Cloud Storage बकेट में मौजूद इमेज के लिए साइन किए गए URL जेनरेट कर सकते हैं।

```python
def get_gcs_signed_url(bucket_name: str, blob_name: str) -> str:
    """Generate a signed URL for a GCS object."""
    storage_client = storage.Client.from_service_account_json(GOOGLE_APPLICATION_CREDENTIALS)
    bucket = storage_client.get_bucket(bucket_name)
    blob = bucket.get_blob(blob_name)
    
    url = blob.generate_signed_url(
        version="v4",
        expiration=3600,  # 1 hour in seconds
        method="GET"
    )
    return url
```

उपरोक्त कोड स्निपेट में, आपको अपने Google Cloud Storage बकेट का नाम और ब्लॉब नाम चाहिए। इमेज का साइन किया गया URL जनरेट किया जाता है और रिटर्न किया जाता है।

इसके चारों ओर बनाकर, हम एक पूरा सॉल्यूशन जनरेट कर सकते हैं जो बकेट में उपलब्ध सभी ऑब्जेक्ट्स को खींचता है, और फिर उन्हें API के माध्यम से Roboflow पर अपलोड करता है। इस सॉल्यूशन का एक रूपरेखा नीचे देखी जा सकती है:

```python
from google.cloud import storage
import requests
import urllib.parse

# ************* SET THESE VARIABLES *************
GCS_BUCKET_NAME = "YOUR_GCS_BUCKET_NAME"
ROBOFLOW_API_KEY = "YOUR_ROBOFLOW_API_KEY"
ROBOFLOW_PROJECT_NAME = "YOUR_ROBOFLOW_PROJECT_NAME"
GOOGLE_APPLICATION_CREDENTIALS = "path/to/your-service-account-file.json"
# ***********************************************

def get_gcs_signed_url(bucket_name: str, blob_name: str) -> str:
    """Generate a signed URL for a GCS object."""
    storage_client = storage.Client.from_service_account_json(GOOGLE_APPLICATION_CREDENTIALS)
    bucket = storage_client.get_bucket(bucket_name)
    blob = bucket.get_blob(blob_name)
    
    url = blob.generate_signed_url(
        version="v4",
        expiration=3600,  # 1 hour in seconds
        method="GET"
    )
    return url

def get_gcs_objects(bucket_name: str) -> list:
    """Fetch the list of object keys in the given GCS bucket."""
    storage_client = storage.Client.from_service_account_json(GOOGLE_APPLICATION_CREDENTIALS)
    bucket = storage_client.get_bucket(bucket_name)
    blobs = bucket.list_blobs()

    object_names = []
    for blob in blobs:
        object_names.append(blob.name)
    return object_names

def upload_to_roboflow(api_key: str, project_name: str, presigned_url: str, img_name='', split="train"):
    """Upload an image to Roboflow."""
    API_URL = "https://api.roboflow.com"
    if img_name == '':
        img_name = presigned_url.split("/")[-1]

    upload_url = "".join([
        API_URL + "/dataset/" + project_name + "/upload",
        "?api_key=" + api_key,
        "&name=" + img_name,
        "&split=" + split,
        "&image=" + urllib.parse.quote_plus(presigned_url),
    ])
    response = requests.post(upload_url)

    # Check response code
    if response.status_code == 200:
        print(f"Successfully uploaded {img_name} to {project_name}")
        return True
    else:
        print(f"Failed to upload {img_name}. Error: {response.content.decode('utf-8')}")
        return False

if __name__ == "__main__":
    # Fetch list of available blobs
    available_blobs = get_gcs_objects(GCS_BUCKET_NAME)
    
    # Optional: Filter the blobs here
    # e.g., available_blobs = [blob for blob in available_blobs if "some_condition"]
    
    # Upload blobs to Roboflow
    for blob in available_blobs:
        blob_url = get_gcs_signed_url(GCS_BUCKET_NAME, blob)
        upload_to_roboflow(ROBOFLOW_API_KEY, ROBOFLOW_PROJECT_NAME, blob_url)

```

### Option 2: Download Data Locally from GCP

GCP से डेटा डाउनलोड करने के लिए, पहले GCP CLI इंस्टॉल करें। फिर अपने GCP यूजर अकाउंट से ऑथेंटिकेट करें।

किसी इमेज या इमेज फ़ोल्डर को डाउनलोड करने के लिए, निम्नलिखित कमांड का उपयोग करें:

```bash
gsutil cp -r gs://mybucket/folder .
```

Replace `mybucket` with the name of your GCP storage bucket and `folder` with the destination of the file or folder you want to copy. This command will save the target file or folder to your current working directory (`.`).

### Upload Data to Roboflow

अब जब हमने डेटा डाउनलोड कर लिया है, तो हम इसे Roboflow पर या तो [Upload Web Interface](https://docs.roboflow.com/roboflow/roboflow-hi/datasets/adding-data/..#upload-data-with-the-web-interface) या [Roboflow CLI](https://app.gitbook.com/s/e5GEiPeDoFksvZv1vH3A/command-line-interface/upload-a-dataset).

### पर भी पोस्ट कर सकते हैं

* [Retrieve a Roboflow project ID](https://docs.roboflow.com/api-reference/workspace-and-project-ids)