Konfigurieren der Gültigkeitsdauer in Azure Cosmos DB

GILT FÜR: NoSQL

In Azure Cosmos DB können Sie die Ablaufzeit (TTL) auf Containerebene konfigurieren oder sie auf Elementebene außer Kraft setzen, nachdem Sie TTL für den Container festgelegt haben. Sie können TTL für einen Container mithilfe des Azure-Portals oder der sprachspezifischen SDKs konfigurieren. TTL-Außerkraftsetzungen auf Elementebene können mithilfe der SDKs konfiguriert werden.

Tipp

Dieser Inhalt des Artikels bezieht sich auf die Gültigkeitsdauer des Azure Cosmos DB-Transaktionsspeichers. Wenn Sie nach TTL für analytische Speicher suchen, der NoETL-HTAP-Szenarien über Azure Synapse Link ermöglicht, lesen Sie Analytical Time-to-Live-.

Aktivieren von TTL auf einem Container mithilfe des Azure-Portals

Führen Sie die folgenden Schritte aus, um TTL für einen Container ohne Ablauf zu aktivieren. Wenn TTL auf Containerebene aktiviert wird, kann derselbe Wert auf der Ebene eines einzelnen Elements überschrieben werden. Sie können die TTL auch festlegen, indem Sie einen Wert ungleich Null für Sekunden eingeben.

Melden Sie sich beim Azure-Portal an.
Erstellen Sie ein neues Azure Cosmos DB-Konto, oder wählen Sie ein bereits vorhandenes Konto aus.
Öffnen Sie den Bereich Daten-Explorer.
Wählen Sie einen vorhandenen Container aus, erweitern Sie die Registerkarte "Einstellungen ", und ändern Sie die folgenden Werte:
1. Suchen Sie unter EinstellungenTime to Live.
2. Basierend auf Ihren Anforderungen können Sie:
- Deaktivieren Sie diese Einstellung.
- Legen Sie sie auf "Ein" fest (keine Standardeinstellung).
- Aktivieren Sie dies mit einem in Sekunden angegebenen TTL-Wert.
1. Klicken Sie zum Speichern der Änderungen auf Speichern.

Wenn DefaultTimeToLive null ist, ist Ihre TTL deaktiviert.
Wenn DefaultTimeToLive-1 ist, ist Ihre TTL-Einstellung "Ein " (Keine Standardeinstellung).
Wenn DefaultTimeToLive einen anderen ganzzahligen Wert aufweist (mit Ausnahme von 0), ist Ihre TTL-Einstellung aktiviert. Der Server löscht Elemente automatisch basierend auf dem konfigurierten Wert.

Aktivieren von TTL auf einem Container mithilfe von Azure CLI oder Azure PowerShell

Informationen zum Erstellen oder Aktivieren von TTL in einem Container finden Sie unter:

Aktivieren von TTL auf einem Container mithilfe eines SDK

Database database = client.GetDatabase("database");

ContainerProperties properties = new ()
{
    Id = "container",
    PartitionKeyPath = "/customerId",
    // Never expire by default
    DefaultTimeToLive = -1
};

// Create a new container with TTL enabled and without any expiration value
Container container = await database
    .CreateContainerAsync(properties);

CosmosDatabase database = client.getDatabase("database");

CosmosContainerProperties properties = new CosmosContainerProperties(
    "container",
    "/customerId"
);
// Never expire by default
properties.setDefaultTimeToLiveInSeconds(-1);

// Create a new container with TTL enabled and without any expiration value
CosmosContainerResponse response = database
    .createContainerIfNotExists(properties);

const database = await client.database("database");

const properties = {
    id: "container",
    partitionKey: "/customerId",
    // Never expire by default
    defaultTtl: -1
};

const { container } = await database.containers
    .createIfNotExists(properties);

database = client.get_database_client('database')

database.create_container(
    id='container',
    partition_key=PartitionKey(path='/customerId'),
    # Never expire by default
    default_ttl=-1
)

db, _ := c.NewDatabase("demo_db")

pkDefinition := azcosmos.PartitionKeyDefinition{
	Paths: []string{"/state"},
	Kind:  azcosmos.PartitionKeyKindHash,
}

// Never expire by default
ttl := int32(-1)

db.CreateContainer(context.Background(), azcosmos.ContainerProperties{
	ID:                     "demo_container",
	PartitionKeyDefinition: pkDefinition,
	DefaultTimeToLive:      &ttl,
}, nil)

Festlegen von TTL für einen Container mithilfe eines SDK

Um die TTL für einen Container festzulegen, müssen Sie eine nichtzero positive Zahl angeben, die den Zeitraum in Sekunden angibt. Auf der Grundlage des konfigurierten Werts für die Gültigkeitsdauer werden alle Elemente im Container nach dem Zeitstempel (_ts) der letzten Änderung des Elements gelöscht.

Database database = client.GetDatabase("database");

ContainerProperties properties = new ()
{
    Id = "container",
    PartitionKeyPath = "/customerId",
    // Expire all documents after 90 days
    DefaultTimeToLive = 90 * 60 * 60 * 24
};

// Create a new container with TTL enabled and without any expiration value
Container container = await database
    .CreateContainerAsync(properties);

CosmosDatabase database = client.getDatabase("database");

CosmosContainerProperties properties = new CosmosContainerProperties(
    "container",
    "/customerId"
);
// Expire all documents after 90 days
properties.setDefaultTimeToLiveInSeconds(90 * 60 * 60 * 24);

CosmosContainerResponse response = database
    .createContainerIfNotExists(properties);

const database = await client.database("database");

const properties = {
    id: "container",
    partitionKey: "/customerId",
    // Expire all documents after 90 days
    defaultTtl: 90 * 60 * 60 * 24
};

const { container } = await database.containers
    .createIfNotExists(properties);

database = client.get_database_client('database')

database.create_container(
    id='container',
    partition_key=PartitionKey(path='/customerId'),
    # Expire all documents after 90 days
    default_ttl=90 * 60 * 60 * 24
)

db, _ := c.NewDatabase("demo_db")

// Expire all documents after 90 days
ttl := int32(90 * 24 * 60 * 60)

db.CreateContainer(context.Background(), azcosmos.ContainerProperties{
	ID:                     containerName,
	PartitionKeyDefinition: pkDefinition,
	DefaultTimeToLive:      &ttl,
}, nil)

Festlegen von TTL für ein Element mithilfe des Azure-Portals

Zusätzlich zum Festlegen einer Standard-TTL für einen Container können Sie eine TTL für ein Element festlegen. Wenn Sie TTL auf Elementebene festlegen, wird die Standard-TTL des Elements in diesem Container außer Kraft gesetzt.

Um die TTL für ein Element festzulegen, müssen Sie eine positive Zahl angeben, die ungleich null ist und den Zeitraum in Sekunden angibt, nach dem das Element nach dem letzten Änderungszeitstempel des Elements _ts abläuft. Sie können auch -1 angeben, wenn das Element nicht ablaufen sollte.
Wenn das Element nicht über ein TTL-Feld verfügt, gilt standardmäßig der auf den Container festgelegte TTL für das Element.
Wenn TTL auf Containerebene deaktiviert ist, wird das TTL-Feld für das Element ignoriert, bis TTL im Container erneut aktiviert ist.

Führen Sie die folgenden Schritte aus, um TTL für ein Element zu aktivieren:

Melden Sie sich beim Azure-Portal an.
Erstellen Sie ein neues Azure Cosmos DB-Konto, oder wählen Sie ein bereits vorhandenes Konto aus.
Öffnen Sie den Bereich Daten-Explorer.
Wählen Sie einen vorhandenen Container aus, erweitern Sie ihn, und ändern Sie die folgenden Werte:
- Öffnen Sie das Fenster Scale & Settings (Skalierung und Einstellungen).
- Suchen Sie unter Einstellungen nach Lebensdauer.
- Wählen Sie Ein (Standard) oder Ein aus, und legen Sie einen Wert für die Gültigkeitsdauer fest.
- Klicken Sie zum Speichern der Änderungen auf Speichern.

Navigieren Sie zu dem Element, für das Sie die Zeit auf Live festlegen möchten, fügen Sie die ttl Eigenschaft hinzu, und wählen Sie "Aktualisieren" aus.

{
    "id": "1",
    "_rid": "Jic9ANWdO-EFAAAAAAAAAA==",
    "_self": "dbs/Jic9AA==/colls/Jic9ANWdO-E=/docs/Jic9ANWdO-EFAAAAAAAAAA==/",
    "_etag": "\"0d00b23f-0000-0000-0000-5c7712e80000\"",
    "_attachments": "attachments/",
    "ttl": 10,
    "_ts": 1551307496
}

Festlegen von TTL für ein Element mithilfe eines SDK

public record SalesOrder(string id, string customerId, int ttl);

Container container = database.GetContainer("container");

SalesOrder item = new (
    "SO05", 
    "CO18009186470"
    // Expire sales order in 30 days using "ttl" property
    ttl:  60 * 60 * 24 * 30
);

await container.CreateItemAsync<SalesOrder>(item);

public class SalesOrder {

    public String id;

    public String customerId;

    // Include a property that serializes to "ttl" in JSON
    public Integer ttl;

}

CosmosContainer container = database.getContainer("container");

SalesOrder item = new SalesOrder();
item.id = "SO05";
item.customerId = "CO18009186470";
// Expire sales order in 30 days using "ttl" property
item.ttl = 60 * 60 * 24 * 30;

container.createItem(item);

const container = await database.container("container");

const item = {
    id: 'SO05',
    customerId: 'CO18009186470',
    // Expire sales order in 30 days using "ttl" property
    ttl: 60 * 60 * 24 * 30
};

await container.items.create(item);

container = database.get_container_client('container')

item = {
    'id': 'SO05',
    'customerId': 'CO18009186470',
    # Expire sales order in 30 days using "ttl" property
    'ttl': 60 * 60 * 24 * 30
}

container.create_item(body=item)

custInfo := map[string]any{
	"id":    "SO05",
	"customerId": "CO18009186470",
	// Expire sales order in 30 days using "ttl" property
	"ttl": int32(60 * 60 * 24 * 30),
}

container, _ := db.NewContainer(containerName)

item, err := json.Marshal(custInfo)
container.CreateItem(context.Background(), azcosmos.NewPartitionKeyString("CO18009186470"), item, nil)

Zurücksetzen von TTL mithilfe eines SDK

Sie können die TTL für ein Element zurücksetzen, indem Sie einen Schreib- oder Aktualisierungsvorgang für das Element ausführen. Der Schreib- oder Aktualisierungsvorgang legt den _ts Wert auf die aktuelle Uhrzeit fest, und die TTL für das Ablaufen des Elements beginnt erneut. Wenn Sie die Gültigkeitsdauer eines Elements ändern möchten, können Sie das Feld genau wie jedes andere Feld aktualisieren.

SalesOrder item = await container.ReadItemAsync<SalesOrder>(
    "SO05", 
    new PartitionKey("CO18009186470")
);

// Update ttl to 2 hours
SalesOrder modifiedItem = item with { 
    ttl = 60 * 60 * 2 
};

await container.ReplaceItemAsync<SalesOrder>(
    modifiedItem,
    "SO05", 
    new PartitionKey("CO18009186470")    
);

CosmosItemResponse<SalesOrder> response = container.readItem(
    "SO05", 
    new PartitionKey("CO18009186470"),
    SalesOrder.class
);

SalesOrder item = response.getItem();

// Update ttl to 2 hours
item.ttl = 60 * 60 * 2;

CosmosItemRequestOptions options = new CosmosItemRequestOptions();
container.replaceItem(
    item,
    "SO05", 
    new PartitionKey("CO18009186470"),
    options
);

const { resource: item } = await container.item(
    'SO05',
    'CO18009186470'
).read();

// Update ttl to 2 hours
item.ttl = 60 * 60 * 2;

await container.item(
    'SO05',
    'CO18009186470'
).replace(item);

item = container.read_item(
    item='SO05',
    partition_key='CO18009186470'
)

# Update ttl to 2 hours
item['ttl'] = 60 * 60 * 2 

container.replace_item(
    item='SO05',
    body=item
)

// Read the item
resp, _ := container.ReadItem(context.Background(), azcosmos.NewPartitionKeyString("CO18009186470"), "SO05", nil)

var order map[string]any
json.Unmarshal(resp.Value, &order)

// Update ttl to 2 hours
order["ttl"] = int32(120 * 60)
updatedOrder, err = json.Marshal(order)

container.ReplaceItem(context.Background(), azcosmos.NewPartitionKeyString("CO18009186470"), "SO05", updatedOrder, nil)

Deaktivieren von TTL mithilfe eines SDK

Um TTL für einen Container zu deaktivieren und den Hintergrundprozess daran zu hindern, auf abgelaufene Elemente zu überprüfen, sollte die DefaultTimeToLive Eigenschaft für den Container gelöscht werden. Das Löschen dieser Eigenschaft unterscheidet sich von der Einstellung auf -1. Wenn Sie den Wert auf -1 setzen, bleiben neue Elemente, die dem Container hinzugefügt werden, für immer erhalten; allerdings können Sie diesen Wert für bestimmte Elemente im Container überschreiben. Wenn Sie die TTL-Eigenschaft aus dem Container entfernen, laufen die Elemente nie ab, auch wenn sie den vorherigen Standard-TTL-Wert explizit außer Kraft setzen.

ContainerProperties properties = await container.ReadContainerAsync();

// Disable ttl at container-level
properties.DefaultTimeToLive = null;

await container.ReplaceContainerAsync(properties);

CosmosContainerResponse response = container.read();
CosmosContainerProperties properties = response.getProperties();

// Disable ttl at container-level
properties.setDefaultTimeToLiveInSeconds(null);

container.replace(properties);

const { resource: definition } = await container.read();

// Disable ttl at container-level
definition.defaultTtl = null;

await container.replace(definition);

database.replace_container(
    container,
    partition_key=PartitionKey(path='/id'),
    # Disable ttl at container-level
    default_ttl=None
)

containerInfo, _ := container.Read(context.Background(), nil)
props := containerInfo.ContainerProperties

// Disable ttl at container-level
props.DefaultTimeToLive = nil
container.Replace(context.Background(), *props, nil)

Gültigkeitsdauer (TTL) in Azure Cosmos DB

Feedback

War diese Seite hilfreich?

Last updated on 2025-07-24