Utiliser Apache Cassandra dans Go : un guide complet

Apache Cassandra est une base de données non relationnelle (NoSQL) largement utilisée dans les scénarios de stockage de données distribuées à grande échelle, à haut débit et tolérantes aux pannes. Il utilise un modèle de données similaire à Bigtable de Google et le combine avec l'architecture distribuée d'Amazon Dynamo. Dans cet article, nous verrons comment utiliser Apache Cassandra en langage Go et comment l'utiliser pour créer une application Web simple.

Modèle de données de Cassandra

Le modèle de données de Cassandra peut être logiquement considéré comme une table de hachage entièrement distribuée. La table se compose de plusieurs familles de colonnes. Chaque famille de colonnes contient un espace de clé (Keyspace), qui contient plusieurs tables (Table). Chaque table contient plusieurs lignes (Row) et dans chaque ligne, elle peut stocker plusieurs données nommées colonnes (Column). .

Dans Cassandra, vous pouvez utiliser CQL (Cassandra Query Language) pour interroger et manipuler des données. CQL est facile à apprendre et à utiliser car il utilise une syntaxe similaire au langage SQL, mais certains détails de syntaxe sont encore différents.

Étapes pour utiliser Apache Cassandra

Voyons maintenant comment utiliser Apache Cassandra dans votre application Go. Il y a principalement 5 étapes ci-dessous.

1. Installer Cassandra

La première chose à faire est d'installer Cassandra. Vous pouvez vous rendre sur le site officiel de Cassandra pour télécharger le fichier binaire correspondant et l'installer selon les instructions.

2. Créer une famille de colonnes

Après avoir installé Cassandra, l'étape suivante consiste à créer une famille de colonnes et à ajouter quelques colonnes à la famille de colonnes. Vous pouvez utiliser cqlsh (cassandra shell) pour faire fonctionner Cassandra.

Ici, nous avons créé une famille de colonnes nommée « étudiant », qui contient le nom de l'étudiant, le numéro de l'étudiant, la classe et d'autres informations :

CREATE KEYSPACE learning WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'} AND durable_writes = true;

CREATE TABLE learning.students (
   student_id text PRIMARY KEY,
   first_name text,
   last_name text,
   department text
);

3 Connectez-vous à Cassandra

En langage Go, vous pouvez utiliser des bibliothèques tierces pour vous connecter. à Cassandre. Ici, nous utilisons gocql pour nous connecter.

Voici un exemple de code pour vous connecter à un cluster Cassandra :

cluster := gocql.NewCluster("127.0.0.1")
cluster.Keyspace = "learning"
session, err := cluster.CreateSession()
if err != nil {
    log.Fatal(err)
}
defer session.Close()

Ici, il vous suffit de spécifier l'adresse IP ou le nom d'hôte du cluster Cassandra et de spécifier l'espace de clés auquel vous souhaitez vous connecter.

4. Écrire des instructions de requête

En langage Go, vous pouvez utiliser gocql.Query pour écrire des instructions de requête. Voici un exemple de code pour interroger toutes les informations sur les étudiants dans la table :

var students []model.Student

query := "SELECT * FROM students"
iter := session.Query(query).Iter()

for iter.Scan(&student.ID, &student.FirstName, &student.LastName, &student.Department) {
    students = append(students, student)
}

if err := iter.Close(); err != nil {
    log.Fatal(err)
}

for _, student := range students {
    fmt.Println(student.ID, student.FirstName, student.LastName, student.Department)
}

Ici, nous déclarons d'abord une structure model.Student pour stocker les données sur les étudiants extraites de la table. Ensuite, nous avons écrit une instruction de requête SELECT et créé un objet de requête à l'aide de la méthode session.Query. Ensuite, nous parcourons les résultats de la requête, stockons les données dans une tranche, et enfin générons les informations pour tous les étudiants.

5. Fermez la connexion

Enfin, nous devons fermer la connexion avec Cassandra. Voici un exemple de code pour fermer la connexion Cassandra :

defer session.Close()

Création d'une application Web à l'aide de Cassandra

Voyons maintenant comment créer une application Web simple à l'aide d'Apache Cassandra en langage Go. Dans cette application Web, nous créerons une page de liste des étudiants, afficherons les informations de tous les étudiants et fournirons un formulaire pour ajouter des informations sur les étudiants.

Ici, nous utilisons le framework Gin pour créer des applications Web. Voici un exemple de code pour créer une application Web :

package main

import (
    "html/template"
    "log"
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"
    "github.com/gocql/gocql"
)

type Student struct {
    ID         string
    FirstName  string
    LastName   string
    Department string
}

var session *gocql.Session

func init() {
    cluster := gocql.NewCluster("127.0.0.1")
    cluster.Keyspace = "learning"
    var err error
    session, err = cluster.CreateSession()
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    router := gin.Default()

    router.LoadHTMLGlob("templates/*")

    router.GET("/", func(c *gin.Context) {
        var students []Student

        query := "SELECT * FROM students"
        iter := session.Query(query).Iter()

        for {
            var student Student
            if !iter.Scan(&student.ID, &student.FirstName, &student.LastName, &student.Department) {
                break
            }
            students = append(students, student)
        }

        if err := iter.Close(); err != nil {
            log.Fatal(err)
        }

        c.HTML(http.StatusOK, "index.tmpl", gin.H{
            "students": students,
        })
    })

    router.POST("/add", func(c *gin.Context) {
        student := Student{
            ID:         c.PostForm("id"),
            FirstName:  c.PostForm("first_name"),
            LastName:   c.PostForm("last_name"),
            Department: c.PostForm("department"),
        }

        query := "INSERT INTO students (student_id, first_name, last_name, department) VALUES (?, ?, ?, ?)"
        err := session.Query(query, student.ID, student.FirstName, student.LastName, student.Department).Exec()
        if err != nil {
            log.Fatal(err)
        }

        c.Redirect(http.StatusFound, "/")
    })

    router.Run(":8080")
}

Ici, nous déclarons d'abord une structure nommée Student, qui est utilisée pour représenter les informations d'un étudiant. Ensuite, on se connecte au cluster Cassandra dans la fonction init.

Dans la fonction principale, nous utilisons le routage Gin pour gérer différentes requêtes HTTP. Sur le chemin "/", nous interrogeons d'abord les informations de tous les étudiants et les transmettons au modèle index.tmpl pour le rendu de la page de liste des étudiants. Sur le chemin "/add", nous insérons un nouveau dossier d'étudiant basé sur les données du formulaire soumis par l'utilisateur, puis redirigeons l'utilisateur vers la page de la liste des étudiants.

Enfin, nous appelons router.Run() pour démarrer l'application Web.

Résumé

Dans cet article, nous avons expliqué comment utiliser Apache Cassandra en langage Go et créé une application Web simple. À travers cet exemple, nous pouvons voir l'utilisation simple de Cassandra et comment utiliser des bibliothèques tierces pour faire fonctionner Cassandra en langage Go. Si vous recherchez une base de données distribuée à haut débit et haute disponibilité, Apache Cassandra peut être une option pour vous.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!