

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Eine Tabelle in Amazon Keyspaces erstellen
<a name="getting-started.tables"></a>

In diesem Abschnitt erstellen Sie eine Tabelle mit der Konsole oder `cqlsh` dem. AWS CLI

In einer Tabelle werden Ihre Daten organisiert und gespeichert. Der Primärschlüssel Ihrer Tabelle bestimmt, wie Daten in Ihrer Tabelle partitioniert werden. Der Primärschlüssel besteht aus einem erforderlichen Partitionsschlüssel und einer oder mehreren optionalen Clusterspalten. Die kombinierten Werte, aus denen sich der Primärschlüssel zusammensetzt, müssen für alle Daten der Tabelle eindeutig sein. Weitere Informationen zu Tabellen finden Sie in den folgenden Themen:
+ Design des Partitionsschlüssels: [So verwenden Sie Partitionsschlüssel effektiv in Amazon Keyspaces](bp-partition-key-design.md)
+ Mit Tabellen arbeiten: [Überprüfen Sie den Status der Tabellenerstellung in Amazon Keyspaces](tables-create.md)
+ DDL-Anweisungen in der CQL-Sprachreferenz: [Tabellen](cql.ddl.table.md)
+ Verwaltung von Tabellenressourcen: [Verwaltung serverloser Ressourcen in Amazon Keyspaces (für Apache Cassandra)](serverless_resource_management.md)
+ Überwachung der Auslastung der Tabellenressourcen: [Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md)
+ [Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md)

Wenn Sie eine Tabelle erstellen, geben Sie Folgendes an:
+ Der Name der Tabelle.
+ Der Name und der Datentyp jeder Spalte in der Tabelle.
+ Der Primärschlüssel für die Tabelle.
  + **Partitionsschlüssel** — Erforderlich
  + **Spalten gruppieren** — optional

Gehen Sie wie folgt vor, um eine Tabelle mit den angegebenen Spalten, Datentypen, Partitionsschlüsseln und Clusterspalten zu erstellen.

## Verwenden der Konsole
<a name="getting-started.tables.con"></a>

Mit dem folgenden Verfahren wird die Tabelle `book_awards` mit diesen Spalten und Datentypen erstellt.

```
year           int
award          text
rank           int 
category       text
book_title     text
author         text
publisher      text
```

**Um eine Tabelle mit der Konsole zu erstellen**

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).

1. Wählen Sie im Navigationsbereich **Keyspaces** aus.

1. Wählen Sie `catalog` den Schlüsselraum aus, in dem Sie diese Tabelle erstellen möchten.

1. Wählen Sie **Create table** (Tabelle erstellen) aus.

1. Geben Sie **book\$1awards** im Feld **Tabellenname** einen Namen für Ihre Tabelle ein.

   **Einschränkungen für Namen:**
   + Der Name darf nicht leer sein.
   + Zulässige Zeichen: alphanumerische Zeichen und Unterstrich ()`_`.
   + Die maximale Länge beträgt 48 Zeichen.

1. Wiederholen Sie im Abschnitt **Spalten** die folgenden Schritte für jede Spalte, die Sie zu dieser Tabelle hinzufügen möchten.

   Fügen Sie die folgenden Spalten und Datentypen hinzu.

   ```
   year           int
   award          text
   rank           int 
   category       text
   book_title     text
   author         text
   publisher      text
   ```

   1. **Name** — Geben Sie einen Namen für die Spalte ein.

      **Einschränkungen für Namen:**
      + Der Name darf nicht leer sein.
      + Zulässige Zeichen: alphanumerische Zeichen und Unterstrich ()`_`.
      + Die maximale Länge beträgt 48 Zeichen.

   1. **Typ** — Wählen Sie in der Liste der Datentypen den Datentyp für diese Spalte aus.

   1. Um eine weitere Spalte hinzuzufügen, wählen Sie **Spalte hinzufügen** aus.

1. Wählen Sie `award` und `year` als Partitionsschlüssel unter **Partitionsschlüssel** aus. Für jede Tabelle ist ein Partitionsschlüssel erforderlich. Ein Partitionsschlüssel kann aus einer oder mehreren Spalten bestehen. 

1. Fügen Sie `category` und `rank` als **Clustering-Spalten** hinzu. Clusterspalten sind optional und bestimmen die Sortierreihenfolge innerhalb jeder Partition.

   1. Um eine Clusterspalte hinzuzufügen, wählen Sie Clustering-Spalte **hinzufügen** aus.

   1. **Wählen Sie in der **Spaltenliste** die Kategorie aus.** Wählen Sie in der Liste **Reihenfolge** die Option **ASC** aus, um die Werte in dieser Spalte in aufsteigender Reihenfolge zu sortieren. (Wählen Sie **DESC** für eine absteigende Reihenfolge.)

   1. **Wählen Sie dann **Clusterspalte hinzufügen** und anschließend Rang aus.**

1. Wählen Sie im Abschnitt **Tabelleneinstellungen** die Option **Standardeinstellungen** aus.

1. Wählen Sie **Create table** (Tabelle erstellen) aus.

1. Vergewissern Sie sich, dass Ihre Tabelle erstellt wurde.

   1. Wählen Sie im Navigationsbereich **Tables** (Tabellen) aus.

   1. Vergewissern Sie sich, dass Ihre Tabelle in der Tabellenliste enthalten ist.

   1. Wählen Sie den Namen Ihrer Tabelle.

   1. Vergewissern Sie sich, dass alle Ihre Spalten und Datentypen korrekt sind.
**Anmerkung**  
Die Spalten werden möglicherweise nicht in der Reihenfolge aufgeführt, in der Sie sie der Tabelle hinzugefügt haben. 

## Verwenden von CQL
<a name="getting-started.tables.cql"></a>

Dieses Verfahren erstellt mithilfe von CQL eine Tabelle mit den folgenden Spalten und Datentypen. Die `award` Spalten `year` und sind Partitionsschlüssel mit `category` und `rank` als Clusterspalten. Zusammen bilden sie den Primärschlüssel der Tabelle.

```
year           int
award          text
rank           int 
category       text
book_title     text
author         text
publisher      text
```

**Um eine Tabelle mit CQL zu erstellen**

1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.

   ```
   cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
   ```

   Die Ausgabe dieses Befehls sollte so aussehen.

   ```
   Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
   [cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
   Use HELP for help.
   cqlsh current consistency level is ONE.
   ```

1. Erstellen Sie an der Keyspace-Eingabeaufforderung (`cqlsh:keyspace_name>`) Ihre Tabelle, indem Sie den folgenden Code in Ihr Befehlsfenster eingeben.

   ```
   CREATE TABLE catalog.book_awards (
      year int,
      award text,
      rank int, 
      category text,
      book_title text,
      author text, 
      publisher text,
      PRIMARY KEY ((year, award), category, rank)
      );
   ```
**Anmerkung**  
`ASC`ist die standardmäßige Clusterreihenfolge. Sie können auch eine `DESC` absteigende Reihenfolge angeben. 

   Beachten Sie, dass es sich bei den Spalten `year` und um Partitionsschlüsselspalten `award` handelt. Dann `category` und `rank` sind die Clusterspalten in aufsteigender Reihenfolge angeordnet ()`ASC`. Zusammen bilden diese Spalten den Primärschlüssel der Tabelle. 

1. Stellen Sie sicher, dass Ihre Tabelle erstellt wurde.

   ```
   SELECT * from system_schema.tables WHERE keyspace_name='catalog.book_awards' ;
   ```

   Die Ausgabe sollte in etwa so aussehen.

   ```
    keyspace_name | table_name | bloom_filter_fp_chance | caching | cdc | comment | compaction | compression | crc_check_chance | dclocal_read_repair_chance | default_time_to_live | extensions | flags | gc_grace_seconds | id | max_index_interval | memtable_flush_period_in_ms | min_index_interval | read_repair_chance | speculative_retry
   ---------------+------------+------------------------+---------+-----+---------+------------+-------------+------------------+----------------------------+----------------------+------------+-------+------------------+----+--------------------+-----------------------------+--------------------+--------------------+-------------------
   
   (0 rows)
   ```

1. Überprüfen Sie die Struktur Ihrer Tabelle.

   ```
   SELECT * FROM system_schema.columns WHERE keyspace_name = 'catalog' AND table_name = 'book_awards';
   ```

   Die Ausgabe dieser Anweisung sollte diesem Beispiel ähneln.

   ```
    keyspace_name | table_name  | column_name | clustering_order | column_name_bytes      | kind          | position | type
   ---------------+-------------+-------------+------------------+------------------------+---------------+----------+------
          catalog | book_awards |        year |             none |             0x79656172 | partition_key |        0 |  int
          catalog | book_awards |       award |             none |           0x6177617264 | partition_key |        1 | text
          catalog | book_awards |    category |              asc |     0x63617465676f7279 |    clustering |        0 | text
          catalog | book_awards |        rank |              asc |             0x72616e6b |    clustering |        1 |  int
          catalog | book_awards |      author |             none |         0x617574686f72 |       regular |       -1 | text
          catalog | book_awards |  book_title |             none | 0x626f6f6b5f7469746c65 |       regular |       -1 | text
          catalog | book_awards |   publisher |             none |   0x7075626c6973686572 |       regular |       -1 | text
   
   (7 rows)
   ```

   Vergewissern Sie sich, dass alle Spalten und Datentypen Ihren Erwartungen entsprechen. Die Reihenfolge der Spalten kann sich von der Reihenfolge in der `CREATE` Anweisung unterscheiden.

## Unter Verwendung der AWS CLI
<a name="getting-started.tables.cli"></a>

Dieses Verfahren erstellt eine Tabelle mit den folgenden Spalten und Datentypen unter Verwendung von AWS CLI. Die `award` Spalten `year` und bilden den Partitionsschlüssel mit `category` und `rank` als Clusterspalten.

```
year           int
award          text
rank           int 
category       text
book_title     text
author         text
publisher      text
```

**Um eine Tabelle mit dem zu erstellen AWS CLI**

Der folgende Befehl erstellt eine Tabelle mit dem Namen *book\$1awards*. Der Partitionsschlüssel der Tabelle besteht aus den Spalten `year` `award` und der Gruppierungsschlüssel besteht aus den Spalten`rank`, `category` und beide Clusterspalten verwenden die aufsteigende Sortierreihenfolge. (Der besseren Lesbarkeit halber ist `schema-definition` der Befehl table create in diesem Abschnitt in separate Zeilen aufgeteilt.)

1. Sie können die Tabelle mit der folgenden Anweisung erstellen.

   ```
   aws keyspaces create-table --keyspace-name 'catalog' \
                         --table-name 'book_awards' \
                         --schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},
               {name=category,type=text}, {name=author,type=text},{name=book_title,type=text},{name=publisher,type=text}],
               partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]'
   ```

   Dieser Befehl führt zu der folgenden Ausgabe.

   ```
   {
       "resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
   }
   ```

1. Um die Metadaten und Eigenschaften der Tabelle zu bestätigen, können Sie den folgenden Befehl verwenden.

   ```
   aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
   ```

   Dieser Befehl gibt die folgende Ausgabe zurück.

   ```
   {
       "keyspaceName": "catalog",
       "tableName": "book_awards",
       "resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards",
       "creationTimestamp": "2024-07-11T15:12:55.571000+00:00",
       "status": "ACTIVE",
       "schemaDefinition": {
           "allColumns": [
               {
                   "name": "year",
                   "type": "int"
               },
               {
                   "name": "award",
                   "type": "text"
               },
               {
                   "name": "category",
                   "type": "text"
               },
               {
                   "name": "rank",
                   "type": "int"
               },
               {
                   "name": "author",
                   "type": "text"
               },
               {
                   "name": "book_title",
                   "type": "text"
               },
               {
                   "name": "publisher",
                   "type": "text"
               }
           ],
           "partitionKeys": [
               {
                   "name": "year"
               },
               {
                   "name": "award"
               }
           ],
           "clusteringKeys": [
               {
                   "name": "category",
                   "orderBy": "ASC"
               },
               {
                   "name": "rank",
                   "orderBy": "ASC"
               }
           ],
           "staticColumns": []
       },
       "capacitySpecification": {
           "throughputMode": "PAY_PER_REQUEST",
           "lastUpdateToPayPerRequestTimestamp": "2024-07-11T15:12:55.571000+00:00"
       },
       "encryptionSpecification": {
           "type": "AWS_OWNED_KMS_KEY"
       },
       "pointInTimeRecovery": {
           "status": "DISABLED"
       },
       "defaultTimeToLive": 0,
       "comment": {
           "message": ""
       },
       "replicaSpecifications": []
   }
   ```

Um CRUD-Operationen (Create, Read, Update, Delete) für die Daten in Ihrer Tabelle durchzuführen, fahren Sie mit fort[Daten (CRUD) mit CQL in Amazon Keyspaces erstellen, lesen, aktualisieren und löschen](getting-started.dml.md).