Lernprogramm: Verwenden der Microsoft Planetary Computer Pro-APIs zum Aufnehmen und Visualisieren von Daten

STAC -Sammlungen (SpatioTemporal Asset Catalog) werden in einem GeoCatalog verwendet, um verwandte Spatiotemporal-Objekte zu indizieren und zu speichern. In diesem End-to-End-Lernprogramm erstellen Sie eine neue STAC-Sammlung, erfassen Sentinel-2-Bilder in die Sammlung und fragen diese Bilder über die APIs von GeoCatalog ab.

In diesem Tutorial erfahren Sie:

Erstellen Sie Ihre eigene STAC-Sammlung in einem Planetary Computer Pro-GeoCatalog
Satellitenbilder der Europäischen Weltraumorganisation (ESA) in die Sammlung einpflegen
Konfigurieren der Sammlung so, dass die Bilder in der Sammlung in der Weboberfläche des Planetary Computer Pro visualisiert werden können
Abfragen von Daten aus der STAC-Sammlung mithilfe der STAC-API von Planetary Computer Pro

Dieses Lernprogramm zeigt und erläutert Funktionen durch Codeausschnitte, für eine interaktive Notizbuchstiloberfläche, laden Sie dieses Lernprogramm als Jupyter-Notizbuch herunter.

Voraussetzungen

Bevor Sie dieses Lernprogramm ausführen, benötigen Sie einen Planetary Computer Pro GeoCatalog, der in Ihrem Azure-Abonnement bereitgestellt wird. Außerdem benötigen Sie eine Umgebung, um dieses Notizbuch auszuführen und die erforderlichen Pakete zu installieren. Wir empfehlen, dieses Lernprogramm über einen virtuellen Azure Machine Learning-Computer oder die Notizbuchintegration von Visual Studio Code in einer virtuellen Python-Umgebung auszuführen. Dieses Notizbuch sollte jedoch überall ausgeführt werden, wo Sie Jupyter-Notizbücher ausführen können, sofern die folgenden Anforderungen erfüllt sind:

Python 3.10 oder höher
Azure CLI ist installiert, und Sie haben az login ausgeführt, um sich bei Ihrem Azure-Konto anzumelden.
Die im Abschnitt "Lernprogrammoptionen" aufgeführten erforderlichen Anforderungen werden installiert.

Öffnen eines Jupyter-Notizbuchs in Azure Machine Learning oder VS-Code

Melden Sie sich mit der Azure CLI bei Azure an

Der folgende Befehl meldet Sie mithilfe der Azure-Befehlszeilenschnittstelle bei Azure an. Führen Sie den Befehl aus, und folgen Sie den Anweisungen zum Anmelden.

!az login

Lernprogrammoptionen auswählen

Bevor Sie dieses Lernprogramm ausführen, benötigen Sie einen Mitwirkendenzugriff auf eine vorhandene GeoCatalog-Instanz. Geben Sie die URL Ihrer GeoCatalog-Instanz in die variable geocatalog_url ein. In diesem Lernprogramm erstellen Sie eine Sammlung für Sentinel-2-Bilder, die von der Europäischen Weltraumorganisation (ESA) bereitgestellt werden, die derzeit im Planetarischen Computerdatenkatalog von Microsoft gespeichert ist.

# URL for your given GeoCatalog
geocatalog_url = (
    "<GEOCATALOG_URL>"
)
geocatalog_url = geocatalog_url.rstrip("/")  # Remove trailing slash if present

api_version = "2025-04-30-preview"

# User selections for demo

# Collection within the Planetary Computer
pc_collection = "sentinel-2-l2a"

# Bounding box for AOI
bbox_aoi = [-22.455626, 63.834083, -22.395201, 63.880750]

# Date range to search for imagery
param_date_range = "2024-02-04/2024-02-11"

# Maximum number of items to ingest
param_max_items = 6

Importieren der erforderlichen Pakete

Bevor Sie eine STAC-Auflistung erstellen können, müssen Sie einige Python-Pakete importieren und Hilfsfunktionen definieren, um das erforderliche Zugriffstoken abzurufen.

pip install pystac-client azure-identity requests pillow

# Import the required packages
import json
import random
import string
import time
from datetime import datetime, timedelta, timezone
from io import BytesIO
from typing import Any, Optional, Dict

import requests
from azure.identity import AzureCliCredential
from IPython.display import Markdown as md
from IPython.display import clear_output
from PIL import Image
from pystac_client import Client

# Function to get a bearer token for the  Planetary Computer Pro API
MPC_APP_ID = "https://geocatalog.spatio.azure.com"

_access_token = None
def getBearerToken():
    global _access_token
    if not _access_token or datetime.fromtimestamp(_access_token.expires_on) < datetime.now() + timedelta(minutes=5):
        credential = AzureCliCredential()
        _access_token = credential.get_token(f"{MPC_APP_ID}/.default")

    return {"Authorization": f"Bearer {_access_token.token}"}

# Method to print error messages when checking response status
def raise_for_status(r: requests.Response) -> None:
    try:
        r.raise_for_status()
    except requests.exceptions.HTTPError as e:
        try:
            print(json.dumps(r.json(), indent=2))
        except:
            print(r.content)
        finally:
            raise

Erstellen einer STAC-Sammlung

Definieren Sie eine STAC-Sammlungs-JSON

Als Nächstes definieren Sie eine STAC-Auflistung als JSON-Element. Verwenden Sie für dieses Tutorial den JSON-Code einer vorhandenen STAC-Sammlung für die Sentinel-2-l2a-Sammlung in Microsoft Planetary Computer. Ihre Sammlung wird eine zufällige ID und ein Titel zugewiesen, sodass keine Konflikte mit anderen vorhandenen Sammlungen auftreten.

# Load example STAC collection JSON

response = requests.get(
    f"https://planetarycomputer.microsoft.com/api/stac/v1/collections/{pc_collection}"
)
raise_for_status(response)
stac_collection = response.json()

collection_id = pc_collection + "-tutorial-" + str(random.randint(0, 1000))

# Genereate a unique name for the test collection
stac_collection["id"] = collection_id
stac_collection["title"] = collection_id

# Determine the storage account and container for the assets
pc_storage_account = stac_collection.pop("msft:storage_account")
pc_storage_container = stac_collection.pop("msft:container")
pc_collection_asset_container = (
    f"https://{pc_storage_account}.blob.core.windows.net/{pc_storage_container}"
)

# View your STAC collection JSON
stac_collection

Beim Erstellen einer Auflistung in GeoCatalog kann ein Sammlungs-JSON keine Objekte auf Sammlungsebene (z. B. eine Sammlungsminiaturansicht) aufweisen, die der Auflistung zugeordnet sind. Entfernen Sie also zuerst diese vorhandenen Objekte (machen Sie sich keine Sorgen, dass Sie die Miniaturansicht später wieder hinzufügen).

# Save the thumbnail url
thumbnail_url = stac_collection['assets']['thumbnail']['href']

# Remove the assets field from the JSON (you'll see how to add this back later)
print("Removed the following items from the STAC Collection JSON:")
stac_collection.pop('assets')

# Create a STAC collection by posting to the STAC collections API

collections_endpoint = f"{geocatalog_url}/stac/collections"

response = requests.post(
    collections_endpoint,
    json=stac_collection,
    headers=getBearerToken(),
    params={"api-version": api_version}
)

if response.status_code==201:
    print("STAC Collection created named:",stac_collection['title'])
else:
    raise_for_status(response)

Öffnen Sie Ihre GeoCatalog-Weboberfläche, und Sie sollten ihre neue Sammlung auf der Registerkarte "Sammlungen" sehen.

Zugreifen auf die Miniaturansicht für die Sammlung

Als Nächstes möchten Sie unserer Sammlung eine Miniaturansicht hinzufügen, die zusammen mit unserer Sammlung angezeigt werden soll. Verwenden Sie für diese Demo die Miniaturansicht aus der vorhandenen Sentinel-2-Sammlung im Planetencomputer von Microsoft.

# Read thumbnail for your collection

thumbnail_response = requests.get(thumbnail_url)
raise_for_status(thumbnail_response)
img = Image.open(BytesIO(thumbnail_response.content))
img

Fügen Sie eine Miniaturansicht zu Ihrem Planetary Computer Pro GeoCatalog hinzu.

Nachdem Sie die Miniaturansicht angezeigt haben, können Sie sie Ihrer Sammlung hinzufügen, indem Sie sie zusammen mit dem erforderlichen Objekt-JSON-Code am Sammlungsobjekt-API-Endpunkt Ihres GeoCatalogs veröffentlichen.

# Define the GeoCatalog collections API endpoint
collection_assets_endpoint = f"{geocatalog_url}/stac/collections/{collection_id}/assets"

# Read the example thumbnail from this collection from the Planetary Computer
thumbnail = {"file": ("lulc.png", thumbnail_response.content)}

# Define the STAC collection asset type - thumbnail in this case
asset = {
    "data": '{"key": "thumbnail", "href":"", "type": "image/png", '
    '"roles":  ["test_asset"], "title": "test_asset"}'
}

# Post the thumbnail to the GeoCatalog collections asset endpoint
response = requests.post(
    collection_assets_endpoint,
    data=asset,
    files=thumbnail,
    headers=getBearerToken(),
    params={"api-version": api_version}
)

if response.status_code==201:
    print("STAC Collection thumbnail updated for:",stac_collection['title'])
else:
    raise_for_status(response)

Lesen Sie neue Sammlung aus Ihrem Planetary Computer Pro GeoCatalog

Aktualisieren Sie Ihren Browser, und Sie sollten in der Lage sein, die Miniaturansicht anzuzeigen. Sie können die Sammlungs-JSON auch programmgesteuert abrufen, indem Sie den folgenden Aufruf an den Auflistungsendpunkt ausführen:

# Request the collection JSON from your GeoCatalog
collection_endpoint = f"{geocatalog_url}/stac/collections/{stac_collection['id']}"

response = requests.get(
    collection_endpoint,
    json={'collection_id':stac_collection['id']},
    headers=getBearerToken(),
    params={"api-version": api_version}
)

if response.status_code==200:
    print("STAC Collection successfully read:",stac_collection['title'])
else:
    raise_for_status(response)

response.json()

print(f"""
You successfully created a new STAC Collection in GeoCatalog named {collection_id}.
You can view your collection by visiting the GeoCatalog Explorer: {geocatalog_url}/collections
""")

Erfassen von STAC-Elementen und -Objekten

Nachdem Sie diese Sammlung erstellt haben, können Sie neue STAC-Elemente mithilfe der GeoCatalog-Items-API in Ihre STAC-Sammlung aufnehmen! Führen Sie diesen Prozess durch:

Abrufen eines SAS-Tokens vom Planetencomputer von Microsoft
Registrieren des Tokens als Erfassungsquelle im GeoCatalog
Bereitstellen von STAC-Elementen aus dieser Sammlung in die Element-API von GeoCatalog
Überprüfen, ob die Elemente erfolgreich aufgenommen wurden

ingestion_sources_endpoint = f"{geocatalog_url}/inma/ingestion-sources"
ingestion_source_endpoint = lambda id: f"{geocatalog_url}/inma/ingestion-sources/{id}"


def find_ingestion_source(container_url: str) -> Optional[Dict[str, Any]]:

    response = requests.get(
        ingestion_sources_endpoint,
        headers=getBearerToken(),
        params={"api-version": api_version},
    )

    for source in response.json()["value"]:
        ingestion_source_id = source["id"]

        response = requests.get(
            ingestion_source_endpoint(ingestion_source_id),
            headers=getBearerToken(),
            params={"api-version": api_version},
        )
        raise_for_status(response)

        response = response.json()

        if response["connectionInfo"]["containerUrl"] == container_url:
            return response


def create_ingestion_source(container_url: str, sas_token: str):
    response = requests.post(
        ingestion_sources_endpoint,
        json={
            "kind": "SasToken",
            "connectionInfo": {
                "containerUrl": container_url,
                "sasToken": sas_token,
            },
        },
        headers=getBearerToken(),
        params={"api-version": api_version},
    )
    raise_for_status(response)


def remove_ingestion_source(ingestion_source_id: str):
    response = requests.delete(
        ingestion_source_endpoint(ingestion_source_id),
        headers=getBearerToken(),
        params={"api-version": api_version},
    )
    raise_for_status(response)

Befragen Sie den Planetaren Computer

Zuerst müssen Sie den Planetarischen Computer abfragen, um nach Sentinel-2-Bildern zu suchen, die unseren spezifischen Anforderungen entsprechen. In diesem Fall suchen Sie nach Sentinel-2-Bildern im Planetarischen Computer, die den folgenden Kriterien entsprechen:

Sammlung - Bilder aus der Sentinel-2-l2a-Sammlung
Zeitraum - Gesammelt zwischen dem 4. Februar und dem 11. Februar 2024
Interessengebiet: gesammelte Bilder von Süd-Island (definiert als Begrenzungsrahmen)

Durch ausführen dieser Suche können Sie die übereinstimmenden STAC-Elemente im Planetarischen Computer finden.

# Search criteria
print("Using the below parameters to search the Planetary Computer:\n")
print("Collection:", pc_collection)
print("Bounding box for area of interest:",bbox_aoi)
print("Date range:",param_date_range)
print("Max number of items:",param_max_items)

# Query the Planetary Computer

# Connect to the Planetary Computer
catalog = Client.open("https://planetarycomputer.microsoft.com/api/stac/v1")

search = catalog.search(collections=[pc_collection], bbox=bbox_aoi, datetime=param_date_range)
total_items = search.item_collection()

items = total_items[:param_max_items]
print("Total number of matching items:",len(total_items))
print("Total number of items for ingest base on user selected parameter:",len(items))

if total_items==0:
    print("No items matched your user specified parameters used at the top of this demo. Update these parameters")

# Print an example STAC item returned by the Planetary Computer
items[0]

Registrieren einer Erfassungsquelle

Bevor Sie diese STAC-Elemente und ihre zugehörigen Objekte (Bilder) in eine GeoCatalog-Sammlung aufnehmen können, müssen Sie ermitteln, ob Sie eine neue Aufnahmequelle registrieren müssen. Aufnahmequellen werden von GeoCatalog verwendet, um nachzuverfolgen, auf welche Speicherorte (Azure Blob Storage-Container) sie Zugriff hat.

Die Registrierung einer Erfassungsquelle erfolgt durch Bereitstellen eines GeoCatalogs am Speicherort des Speichercontainers und eines SAS-Tokens mit Leseberechtigungen für den Zugriff auf den Container. Wenn STAC-Elemente oder ihre zugehörigen Objekte sich in einem Speichercontainer befinden, auf den Ihr GeoCatalog keinen Zugriff hat, erfolgt keine Erfassung.

Um diesen Prozess zu starten, fordern Sie zuerst ein SAS-Token vom Planetarischen Computer an, das uns Lesezugriff auf den Container gewährt, in dem sich die Sentinel-2-Bilder befinden.

# Request API token from the Planetary Computer

pc_token = requests.get("https://planetarycomputer.microsoft.com/api/sas/v1/token/{}".format(pc_collection)).json()
print(f"Planetary Computer API Token will expire {pc_token['msft:expiry']}")

Versuchen Sie als Nächstes, diesen Azure Blob Storage-Container und das zugeordnete SAS-Token als Aufnahmequelle mit GeoCatalog zu registrieren. Es gibt das Potenzial, dass für diesen Speichercontainer bereits eine Aufnahmequelle vorhanden ist. Wenn ja, suchen Sie die ID der vorhandenen Aufnahmequelle.

Warnung

Wenn eine doppelte Erfassungsquelle mit einem Token gefunden wird, das in den nächsten 15 Minuten abläuft, wird sie gelöscht und ersetzt. Das Löschen einer Erfassungsquelle, die bei einer aktuell ausgeführten Erfassung verwendet wird, kann diese unterbrechen.

existing_ingestion_source: Optional[Dict[str, Any]] = find_ingestion_source(pc_collection_asset_container)

if existing_ingestion_source:
    connection_info = existing_ingestion_source["connectionInfo"]
    expiration = datetime.fromisoformat(connection_info["expiration"].split('.')[0]) # works in all Python 3.X versions
    expiration = expiration.replace(tzinfo=timezone.utc) # set timezone to UTC
    if expiration < datetime.now(tz=timezone.utc) + timedelta(minutes=15):
        print(f"Recreating existing ingestion source for {pc_collection_asset_container}")
        remove_ingestion_source(existing_ingestion_source["id"])
        create_ingestion_source(pc_collection_asset_container, pc_token["token"])
    else:
        print(f"Using existing ingestion source for {pc_collection_asset_container} with expiration {expiration}")
else:
    print(f"Creating ingestion source for {pc_collection_asset_container}")
    create_ingestion_source(pc_collection_asset_container, pc_token["token"])

STAC-Elemente mit der GeoCatalog-Elemente-API erfassen

Nachdem Sie nun eine Aufnahmequelle registriert oder überprüft haben, dass eine Quelle vorhanden ist, nehmen Sie die STAC-Elemente, die Sie im Planetarischen Computer gefunden haben, mithilfe der GeoCatalog-Element-API ein. Dazu werden alle Elemente in der Items-API veröffentlicht, die einen neuen Aufnahmevorgang innerhalb von GeoCatalog erstellt.

# Ingest items

items_endpoint = f"{geocatalog_url}/stac/collections/{collection_id}/items"

operation_ids = []

for item in items:

    item_json = item.to_dict()
    item_json['collection'] = collection_id

    # Remove non-static assets
    del(item_json['assets']['rendered_preview'])
    del(item_json['assets']['preview'])
    del(item_json['assets']['tilejson'])

    response = requests.post(
        items_endpoint,
        json=item_json,
        headers=getBearerToken(),
        params={"api-version": api_version}
    )

    operation_ids.append(response.json()['id'])
    print(f"Ingesting item {item_json['id']} with operation id {response.json()['id']}")

Da die Aufnahme von Sentinel-2-Elementen einige Zeit in Anspruch nehmen kann, können Sie diesen Code ausführen, um den Status Ihrer Aufnahmevorgänge mithilfe der Operations-API von GeoCatalog zu überprüfen.

# Check the status of the operations
operations_endpoint = f"{geocatalog_url}/inma/operations"
# Loop through all the operations ids until the status of each operation ids is "Finished"
pending=True

start = time.time()

while pending:
    # Count the number of operation ids that are finished vs unfinished
    num_running = 0
    num_finished = 0
    num_failed = 0
    clear_output(wait=True)
    for operation_id in operation_ids:
        response = requests.get(
            f"{operations_endpoint}/{operation_id}",
            headers=getBearerToken(),
            params={"api-version": api_version},
        )
        raise_for_status(response)
        status = response.json()["status"]
        print(f"Operation id {operation_id} status: {status}")
        if status == "Running":
            num_running+=1
        elif status == "Failed":
            num_failed+=1
        elif status == "Succeeded":
            num_finished+=1
    
    num_running
    stop=time.time()
    # Print the sumary of num finished, num running and num failed
    
    print("Ingesting Imagery:")
    print(f"\tFinished: {num_finished}\n\tRunning: {num_running}\n\tFailed: {num_failed}")
    print("Time Elapsed (seconds):",str(stop-start))
    
    if num_running == 0:
        pending=False
        print(f"Ingestion Complete!\n\t{num_finished} items ingested.\n\t{num_failed} items failed.")

    else:
        print(f"Waiting for {num_running} operations to finish")
        time.sleep(5)

Sie sollten in der Lage sein, Ihren Webbrowser zu aktualisieren und auf die Registerkarte "Elemente" zu klicken, um diese neu hochgeladenen Elemente anzuzeigen.

Sammlungsverwaltung

Nachdem Sie diese STAC-Elemente und die zugehörigen Objekte (Bilder) in die STAC-Auflistung aufgenommen haben, müssen Sie Ihr GeoCatalog mit einigen anderen Konfigurationsdateien bereitstellen, bevor Sie diese Elemente auf der GeoCatalog-Weboberfläche visualisieren können.

Konfiguration des Sammlungsrenderings

Laden Sie zunächst eine Renderkonfigurationsdatei für diese Sammlung vom Planetarischen Computer herunter. Diese Konfigurationsdatei kann von GeoCatalog gelesen werden, um Bilder auf unterschiedliche Weise innerhalb des Explorers zu rendern. Dies liegt daran, dass STAC-Elemente viele verschiedene Objekte (Bilder) enthalten können, die kombiniert werden können, um vollständig neue Bilder eines bestimmten Bereichs zu erstellen, die sichtbare oder nicht sichtbare Features hervorheben. Sentinel-2 STAC-Elemente weisen beispielsweise über 12 verschiedene Bilder aus verschiedenen Teilen des elektromagnetischen Spektrums auf. Diese Renderkonfiguration weist GeoCatalog an, wie diese Bilder kombiniert werden, sodass bilder in natürlicher Farbe oder falscher Farbe (Color Infrarot) angezeigt werden können.

# Read render JSON from Planetary Computer

render_json = requests.get("https://planetarycomputer.microsoft.com/api/data/v1/mosaic/info?collection={}".format(pc_collection)).json()
render_json['renderOptions']

Nachdem Sie diese Renderoptionenkonfiguration vom Planetarischen Computer gelesen haben, können Sie diese Renderoptionen für die Sammlung aktivieren, indem Sie diese Konfiguration an den Endpunkt für Renderoptionen senden.

# Post render options config to GeoCatalog render-options API

render_config_endpoint = f"{geocatalog_url}/stac/collections/{collection_id}/configurations/render-options"

for render_option in render_json['renderOptions']:

    # Rename render configs such that they can be stored by GeoCatalog
    render_option['id'] = render_option['name'].translate(str.maketrans('', '', string.punctuation)).lower().replace(" ","-")[:30]

    # Post render definition
    response = requests.post(
        render_config_endpoint,
        json=render_option,
        headers=getBearerToken(),
        params={"api-version": api_version}
    )

Mosaic-Definitionen

Ähnlich wie die oben beschriebene Renderkonfiguration ermöglicht uns der GeoCatalog-Explorer, eine oder mehrere Mosaikdefinitionen für die Sammlung anzugeben. Diese Mosaikdefinitionen ermöglichen es uns, geoCatalogs Explorer anzuweisen, wie gefiltert wird, welche Elemente im Explorer angezeigt werden. Beispielsweise weist eine grundlegende Renderkonfiguration (in der nächsten Zelle dargestellt) GeoCatalog an, das neueste Bild für einen bestimmten Bereich anzuzeigen. Erweiterte Renderkonfigurationen ermöglichen es uns, unterschiedliche Ansichten wie das am wenigsten cloudige Bild für einen bestimmten Ort zu rendern, der im Oktober 2023 erfasst wurde.

# Post mosaic definition

mosiacs_config_endpoint = f"{geocatalog_url}/stac/collections/{collection_id}/configurations/mosaics"

response = requests.post(
    mosiacs_config_endpoint,
    json={"id": "mos1",
          "name": "Most recent available",
          "description": "Most recent available imagery in this collection",
          "cql": []
    },
    headers=getBearerToken(),
    params={"api-version": api_version}
)

Öffnen der GeoCatalog-Weboberfläche

Herzlichen Glückwunsch! Sie haben eine Sammlung erstellt, STAC-Elemente und -Objekte hinzugefügt und Ihre Sammlung so aktualisiert, dass sie die erforderlichen Konfigurationsdateien enthält, damit sie über den Explorer in der GeoCatalog-Weboberfläche angezeigt werden kann.

Navigieren Sie zurück zum GeoCatalog-Explorer in der Weboberfläche, um Ihre Sammlung anzuzeigen!

Abfragesammlung über STAC-API

Nachdem Sie Ihre Sammlung im GeoCatalog-Explorer angezeigt haben, erfahren Sie, wie Sie mithilfe der STAC-APIs von GeoCatalog nach STAC-Elementen und -Objekten suchen und abrufen können, um weitere Analysen zu erhalten.

Dieser Prozess beginnt mit der Veröffentlichung einer Suche in der STAC-API Ihres GeoCatalogs. Sie werden insbesondere in Ihrer Sammlung nach Bildern suchen, die im ursprünglichen Begrenzungsrahmen liegen, den Sie zum Extrahieren von Bildern aus Planetary Computer verwendet haben.

Diese Abfrage gibt nicht überraschend alle STAC-Elemente zurück, die Sie zuvor in Ihrer Sammlung platziert haben.

stac_search_endpoint = f"{geocatalog_url}/stac/search"

response = requests.post(
    stac_search_endpoint,
    json={"collections":[collection_id],
          "bbox":bbox_aoi
    },
    headers=getBearerToken(),
    params={"api-version": api_version, "sign": "true"}
)

matching_items = response.json()['features']
print(len(matching_items))

In Ihrer vorherigen Abfrage haben Sie auch einen anderen Parameter angegeben: sign:true. Dadurch wird GeoCatalog angewiesen, ein signiertes href (Element href + SAS-Token) zurückzugeben, mit dem Sie die angegebenen Ressourcen aus Azure Blob Storage lesen können.

# Download one of the assets bands, band 09
asset_href = matching_items[0]['assets']['B09']['href']
print(asset_href)

response = requests.get(asset_href)
img = Image.open(BytesIO(response.content))
img

Bereinigen von Ressourcen

Elemente löschen

Zu diesem Zeitpunkt haben Sie eine GeoCatalog-Auflistung erstellt, der Sammlung Elemente und Objekte hinzugefügt und diese Elemente und Objekte mithilfe der STAC-API von GeoCatalog abgerufen. In der letzten Phase dieses Lernprogramms entfernen Sie diese Elemente und löschen Ihre Sammlung.

# Delete all items

for item in matching_items:
    response = requests.delete(
        f"{items_endpoint}/{item['id']}",
        headers=getBearerToken(),
        params={"api-version": api_version}
    )

Sie können bestätigen, dass alle Ihre Elemente gelöscht wurden, indem Sie den nächsten Befehl ausführen. Beachten Sie, dass es eine oder zwei Minuten dauern kann, bis Elemente und die zugehörigen Ressourcen vollständig gelöscht werden.

# Confirm that all the items have been deleted
response = requests.post(
    stac_search_endpoint,
    json={"collections":[stac_collection['id']],
          "bbox": bbox_aoi
    },
    headers=getBearerToken(),
    params={"api-version": api_version, "sign": "true"}
)

matching_items = response.json()['features']
print(len(matching_items))

Sammlung löschen

Als letzten Schritt möchten Sie Ihre Sammlung möglicherweise vollständig aus Ihrer GeoCatalog-Instanz löschen.

# Delete the collection
response = requests.delete(
    f"{collections_endpoint}/{collection_id}",
    headers=getBearerToken(),
    params={"api-version": api_version}
)

raise_for_status(response)
print(f"STAC Collection deleted: {collection_id}")

Nächste Schritte

Erstellen einer STAC-Auflistung über die Weboberfläche

In diesem End-to-End-Lernprogramm sind Sie durch den Prozess der Erstellung einer neuen STAC-Sammlung gegangen, haben Sentinel-2-Bilder in die Sammlung aufgenommen und diese Bilder über GeoCatalogs APIs abgefragt. Wenn Sie mehr über die einzelnen Themen erfahren möchten, erkunden Sie die folgenden anderen Materialien:

Feedback

War diese Seite hilfreich?

Last updated on 2025-05-20