Snabbstart: Azure Cosmos DB för Apache Cassandra-klientbiblioteket för Go

Kom igång med Azure Cosmos DB för Apache Cassandra-klientbiblioteket för Go för att lagra, hantera och fråga ostrukturerade data. Följ stegen i den här guiden för att skapa ett nytt konto, installera ett Go-klientbibliotek, ansluta till kontot, utföra vanliga åtgärder och köra frågor mot dina slutliga exempeldata.

API-referensdokumentation | Källkod | för bibliotekPaket (Go)

Förutsättningar

• En prenumeration på Azure

  • Om du inte har en Azure-prenumeration, skapa ett gratis konto innan du börjar.

• Den senaste versionen av Azure CLI i Azure Cloud Shell.

  • Om du föredrar att köra CLI-referenskommandon lokalt loggar du in på Azure CLI med hjälp az login av kommandot .

• Go 1.24 eller senare

Förbereda

Konfigurera först konto- och utvecklingsmiljön för den här guiden. Det här avsnittet beskriver hur du skapar ett konto, hämtar dess autentiseringsuppgifter och sedan förbereder utvecklingsmiljön.

Skapa ett konto

Börja med att skapa ett API för Apache Cassandra-konto. När kontot har skapats skapar du nyckelområdet och tabellresurserna.

Hämta autentiseringsuppgifter

Hämta nu lösenordet för klientbiblioteket som ska användas för att skapa en anslutning till det nyligen skapade kontot.

Förbereda utvecklingsmiljön

Konfigurera sedan utvecklingsmiljön med ett nytt projekt och klientbiblioteket. Det här steget är det sista nödvändiga kravet innan du går vidare till resten av den här guiden.

1. Börja i en tom katalog.

2. Skapa en ny Go-modul.

   go mod init quickstart
   

3. github.com/apache/cassandra-gocql-driver/v2 Importera paketet från Go.

   go get github.com/apache/cassandra-gocql-driver/v2
   

4. Skapa filen main.go .

5. Lägg till mallkoden för Go-applikationen.

   package main
   
   func main() {    
   }
   

   Viktigt!

   De återstående stegen i den här guiden förutsätter att du lägger till din kod i main funktionen.

Objektmodell

Kodexempel

• Autentisera klient
• Upsert-data
• Läsa data
• Fråga efter data

Autentisera klient

Börja med att autentisera klienten med de autentiseringsuppgifter som samlats in tidigare i den här guiden.

1. Öppna filen main.go i din integrerade utvecklingsmiljö (IDE).

2. main I funktionen importerar du följande paket tillsammans med github.com/apache/cassandra-gocql-driver/v2 paketet:

   • context
   • crypto/tls

   import (
       "context"
       "crypto/tls"
       "github.com/apache/cassandra-gocql-driver/v2"
   )
   

3. Skapa strängvariabler för de autentiseringsuppgifter som samlats in tidigare i den här guiden. Ge variablerna username, password och contactPoint namn.

   username := "<username>"
   password := "<password>"
   contactPoint := "<contact-point>"
   

4. Konfigurera en instans av typen PasswordAuthenticator med de autentiseringsuppgifter som angavs i föregående steg. Lagra resultatet i en variabel med namnet authentication.

   authentication := gocql.PasswordAuthenticator{
       Username: username,
       Password: password,
   }
   

5. Konfigurera en instans av SslOptions med en minsta version av TLS (Transport Layer Security) 1.2 och variabeln contactPoint som målservernamn. Lagra resultatet i en variabel med namnet sslOptions.

   sslOptions := &gocql.SslOptions{
       Config: &tls.Config{
           MinVersion: tls.VersionTLS12,
           ServerName: contactPoint,
       },
   }
   

6. Skapa en ny klusterspecifikation med hjälp av NewCluster och variabeln contactPoint .

   cluster := gocql.NewCluster(contactPoint)
   

7. Konfigurera klustrets specifikationsobjekt med hjälp av de autentiserings- och konfigurationsvariabler som skapades i föregående steg.

   cluster.SslOpts = sslOptions
   cluster.Authenticator = authentication
   

8. Konfigurera resten av klustrets specifikationsobjekt med dessa statiska värden.

   cluster.Keyspace = "cosmicworks"
   cluster.Port = 10350
   cluster.ProtoVersion = 4    
   

9. Skapa en ny session som ansluter till klustret med hjälp av CreateSession.

   session, _ := cluster.CreateSession()
   

10. Konfigurera sessionen så att funktionen Close anropas efter att funktionen main har returnerat.

    defer session.Close()
    

11. Skapa ett nytt Background kontextobjekt och lagra det i variabeln ctx .

    ctx := context.Background()
    

Infoga eller uppdatera data

Därefter ökar du nya data till en tabell. Upserting säkerställer att data skapas eller ersätts på lämpligt sätt beroende på om samma data redan finns i tabellen.

1. Definiera en ny typ med namnet Product med fält som motsvarar tabellen som skapades tidigare i den här guiden.

   type Product struct {
       id        string
       name      string
       category  string
       quantity  int
       clearance bool
   }
   

   Tips/Råd

   I Go kan du skapa den här typen i en annan fil eller skapa den i slutet av den befintliga filen.

2. Skapa ett nytt objekt av typen Product. Lagra objektet i en variabel med namnet product.

   product := Product {
       id:        "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
       name:      "Yamba Surfboard",
       category:  "gear-surf-surfboards",
       quantity:  12,
       clearance: false,
   }
   

3. Skapa en ny strängvariabel med namnet insertQuery med frågan Cassandra Query Language (CQL) för att infoga en ny rad.

   insertQuery := `
       INSERT INTO
           product (id, name, category, quantity, clearance)
       VALUES
           (?, ?, ?, ?, ?)
   `
   

4. Använd funktionerna Query och ExecContext för att köra frågan. Skicka in olika egenskaper för variabeln product som frågeparametrar.

   _ = session.Query(
       insertQuery,
       product.id, 
       product.name, 
       product.category, 
       product.quantity, 
       product.clearance,
   ).ExecContext(ctx)
   

Läs data

Läs sedan data som tidigare har laddats upp i tabellen.

1. Skapa en ny strängvariabel med namnet readQuery med en CQL-fråga som matchar objekt med samma id fält.

   readQuery := `
       SELECT
           id,
           name,
           category,
           quantity,
           clearance
       FROM
           product
       WHERE id = ?
       LIMIT 1
   `
   

2. Skapa en strängvariabel id med namnet med samma värde som den produkt som skapades tidigare i den här guiden.

   id := "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb" 
   

3. Skapa en annan variabel med namnet matchedProduct för att lagra resultatet av den här åtgärden i.

   var matchedProduct Product
   

4. QueryAnvänd funktionerna , Consistency, IterContextoch Scan tillsammans för att hitta det enda objekt som matchar frågan och tilldela dess egenskaper till variabelnmatchedProduct.

   session.Query(
       readQuery,
       &id,
   ).Consistency(gocql.One).IterContext(ctx).Scan(
       &matchedProduct.id,
       &matchedProduct.name,
       &matchedProduct.category,
       &matchedProduct.quantity,
       &matchedProduct.clearance,
   )
   

Fråga efter data

Slutligen använder du en fråga för att hitta alla data som matchar ett specifikt filter i tabellen.

1. Skapa strängvariabler med namnet findQuery och category med CQL-frågan och den obligatoriska parametern.

   findQuery := `
       SELECT
           id,
           name,
           category,
           quantity,
           clearance
       FROM
           product
       WHERE
           category = ?
       ALLOW FILTERING
   `
   
   category := "gear-surf-surfboards"
   

2. QueryAnvänd funktionerna , Consistency, IterContextoch Scanner tillsammans för att skapa en skanner som kan iterera över flera objekt som matchar frågan.

   queriedProducts := session.Query(
       findQuery, 
       &category,
   ).Consistency(gocql.All).IterContext(ctx).Scanner()
   

3. Next Använd funktionerna och Scan för att iterera över frågeresultaten och tilldela egenskaperna för varje resultat till den inre queriedProduct variabeln.

   for queriedProducts.Next() {
       var queriedProduct Product
       queriedProducts.Scan(
           &queriedProduct.id,
           &queriedProduct.name,
           &queriedProduct.category,
           &queriedProduct.quantity,
           &queriedProduct.clearance,
       )
       // Do something here with each result
   }
   

Kör koden

Kör det nyligen skapade programmet med hjälp av en terminal i programkatalogen.

go run .

Rensa resurser

Hämta nu lösenordet för klientbiblioteket som ska användas för att skapa en anslutning till det nyligen skapade kontot.

Nästa steg