Connect with Go#

This example connects to an Aiven for Apache Cassandra® service from Go as the avnadmin user by making use of the gocql library.

Variables#

These are the placeholders you will need to replace in the code sample:

Variable	Description
`HOST`	Host name of your Cassandra service
`PORT`	Port number used for connecting to your Cassandra service
`USER`	Username used for connecting to your Cassandra service. Defaults to `avnadmin`
`PASSWORD`	Password of the `avnadmin` user
`SSL-CERTFILE`	Path to the CA Certificate file of your Cassandra service

Pre-requisites#

Get the gocql library:

go get github.com/gocql/gocql

Code#

Create a new file named main.go and add the following content:

package main

import (
	"flag"
	"fmt"
	"log"
	"time"

	"github.com/gocql/gocql"
)

func main() {
	var args = parseArgs()
	cassandraExample(args)
}

type Args struct {
	Host        string
	Port        int
	Username    string
	Password    string
	SSLCertfile string
}

func parseArgs() Args {
	var args Args
	flag.StringVar(&args.Host, "host", "", "Cassandra host")
	flag.IntVar(&args.Port, "port", -1, "Cassandra port")
	flag.StringVar(&args.Username, "user", "avnadmin", "Cassandra username")
	flag.StringVar(&args.Password, "password", "", "Cassandra password")
	flag.StringVar(&args.SSLCertfile, "ssl-certfile", "./ca.pem", "Path to project CA certificate")
	flag.Parse()

	if args.Host == "" {
		fail("-host is required")
	} else if args.Port == -1 {
		fail("-port is required")
	} else if args.Password == "" {
		fail("-password is required")
	}
	return args
}

func fail(message string) {
	flag.Usage()
	log.Fatal(message)
}

func cassandraExample(args Args) {
	var session = createSession(args)
	defer session.Close()
	createSchema(session)
	writeData(session)
	readData(session)
}

func createSession(args Args) gocql.Session {
	cluster := gocql.NewCluster(args.Host)
	cluster.ConnectTimeout = 10 * time.Second
	cluster.Port = args.Port
	cluster.ProtoVersion = 4
	cluster.Authenticator = gocql.PasswordAuthenticator{
		Username: args.Username,
		Password: args.Password,
	}
	cluster.SslOpts = &gocql.SslOptions{
		CaPath: args.SSLCertfile,
	}
	cluster.Consistency = gocql.Quorum

	session, err := cluster.CreateSession()
	if err != nil {
		log.Fatal(err)
	}
	return *session
}

func createSchema(session gocql.Session) {
	if err := session.Query(
		"CREATE KEYSPACE IF NOT EXISTS example_keyspace WITH REPLICATION = {'class': 'NetworkTopologyStrategy', 'aiven': 3}",
	).Exec(); err != nil {
		log.Fatal(err)
	}
	if err := session.Query(
		"CREATE TABLE IF NOT EXISTS example_keyspace.example_go (id int PRIMARY KEY, message text)",
	).Exec(); err != nil {
		log.Fatal(err)
	}
}

func writeData(session gocql.Session) {
	if err := session.Query(
		"INSERT INTO example_keyspace.example_go (id, message) VALUES (?, ?)", 1, "hello world",
	).Exec(); err != nil {
		log.Fatal(err)
	}
}

func readData(session gocql.Session) {
	iter := session.Query("SELECT id, message FROM example_keyspace.example_go").Iter()
	var id int
	var message string
	for iter.Scan(&id, &message) {
		fmt.Printf("Row: id = %d, message = %s\n", id, message)
	}
	if err := iter.Close(); err != nil {
		log.Fatal(err)
	}
}

This code first creates a keyspace named example_keyspace and a table named example_go that contains an id and a message. Then, it writes a new entry into the table with the values 1 and hello world. Finally, it reads the entry from the table and prints it.

Execute the following from a terminal window to build an executable:
```
go build main.go
```

Run the program with the required flags to pass the necessary connection details:

./main --host <HOST> --port <PORT> --user avnadmin --password <PASSWORD> --ssl-certfile <PATH TO CERTFILE>