DOC-4543 split Go client page and removed Connect folder level

Author: andy-stark-redis

content/develop/connect/clients/_index.md renamed to content/develop/clients/_index.md

@@ -12,7 +12,7 @@ categories:
 description: Connect your application to a Redis database and try an example
 linkTitle: Clients
 title: Connect with Redis clients
-weight: 45
+weight: 30
 ---
 
 Use the Redis client libraries to connect to Redis servers from

content/develop/connect/clients/client-side-caching.md renamed to content/develop/clients/client-side-caching.md

@@ -0,0 +1,193 @@
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Go application to a Redis database
+linkTitle: Go
+title: Go guide
+weight: 5
+---
+
+[`go-redis`](https://github.com/redis/go-redis) is the [Go](https://go.dev/) client for Redis.
+The sections below explain how to install `go-redis` and connect your application to a Redis database.
+
+`go-redis` requires a running Redis or
+[Redis Stack]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) server.
+See [Getting started]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis installation
+instructions.
+
+## Install
+
+`go-redis` supports the last two Go versions. You can only use it from within
+a Go module, so you must initialize a Go module before you start, or add your code to
+an existing module:
+
+```
+go mod init github.com/my/repo
+```
+
+Use the `go get` command to install `go-redis/v9`:
+
+```
+go get github.com/redis/go-redis/v9
+```
+
+## Connect
+
+The following example shows the simplest way to connect to a Redis server:
+
+```go
+import (
+	"context"
+	"fmt"
+	"github.com/redis/go-redis/v9"
+)
+
+func main() {    
+    client := redis.NewClient(&redis.Options{
+        Addr:	  "localhost:6379",
+        Password: "", // No password set
+        DB:		  0,  // Use default DB
+        Protocol: 2,  // Connection protocol
+    })
+}
+```
+
+You can also connect using a connection string:
+
+```go
+opt, err := redis.ParseURL("redis://<user>:<pass>@localhost:6379/<db>")
+if err != nil {
+	panic(err)
+}
+
+client := redis.NewClient(opt)
+```
+
+After connecting, you can test the connection by  storing and retrieving
+a simple [string]({{< relref "/develop/data-types/strings" >}}):
+
+```go
+ctx := context.Background()
+
+err := client.Set(ctx, "foo", "bar", 0).Err()
+if err != nil {
+    panic(err)
+}
+
+val, err := client.Get(ctx, "foo").Result()
+if err != nil {
+    panic(err)
+}
+fmt.Println("foo", val)
+```
+
+You can also easily store and retrieve a [hash]({{< relref "/develop/data-types/hashes" >}}):
+
+```go
+hashFields := []string{
+    "model", "Deimos",
+    "brand", "Ergonom",
+    "type", "Enduro bikes",
+    "price", "4972",
+}
+
+res1, err := rdb.HSet(ctx, "bike:1", hashFields).Result()
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(res1) // >>> 4
+
+res2, err := rdb.HGet(ctx, "bike:1", "model").Result()
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(res2) // >>> Deimos
+
+res3, err := rdb.HGet(ctx, "bike:1", "price").Result()
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(res3) // >>> 4972
+
+res4, err := rdb.HGetAll(ctx, "bike:1").Result()
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(res4)
+// >>> map[brand:Ergonom model:Deimos price:4972 type:Enduro bikes]
+ ```
+
+ Use
+ [struct tags](https://stackoverflow.com/questions/10858787/what-are-the-uses-for-struct-tags-in-go)
+ of the form `redis:"<field-name>"` with the `Scan()` method to parse fields from
+ a hash directly into corresponding struct fields:
+
+ ```go
+type BikeInfo struct {
+    Model string `redis:"model"`
+    Brand string `redis:"brand"`
+    Type  string `redis:"type"`
+    Price int    `redis:"price"`
+}
+
+var res4a BikeInfo
+err = rdb.HGetAll(ctx, "bike:1").Scan(&res4a)
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Printf("Model: %v, Brand: %v, Type: %v, Price: $%v\n",
+    res4a.Model, res4a.Brand, res4a.Type, res4a.Price)
+// >>> Model: Deimos, Brand: Ergonom, Type: Enduro bikes, Price: $4972
+ ```
+
+## Observability
+
+`go-redis` supports [OpenTelemetry](https://opentelemetry.io/) instrumentation.
+to monitor performance and trace the execution of Redis commands.
+For example, the following code instruments Redis commands to collect traces, logs, and metrics:
+
+```go
+import (
+    "github.com/redis/go-redis/v9"
+    "github.com/redis/go-redis/extra/redisotel/v9"
+)
+
+rdb := redis.NewClient(&redis.Options{...})
+
+// Enable tracing instrumentation.
+if err := redisotel.InstrumentTracing(rdb); err != nil {
+	panic(err)
+}
+
+// Enable metrics instrumentation.
+if err := redisotel.InstrumentMetrics(rdb); err != nil {
+	panic(err)
+}
+```
+
+See the `go-redis` [GitHub repo](https://github.com/redis/go-redis/blob/master/example/otel/README.md).
+for more OpenTelemetry examples.
+
+## More information
+
+See the other pages in this section for more information and examples.
+Further examples are available at the [`go-redis`](https://redis.uptrace.dev/guide/) website
+and the [GitHub repository](https://github.com/redis/go-redis).

content/develop/connect/clients/dotnet/_index.md renamed to content/develop/clients/dotnet/_index.md

@@ -0,0 +1,130 @@
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Go application to a Redis database
+linkTitle: Connect
+title: Connect to the server
+weight: 1
+---
+
+## Basic connection
+
+## Connect
+
+The following example shows the simplest way to connect to a Redis server:
+
+```go
+import (
+	"context"
+	"fmt"
+	"github.com/redis/go-redis/v9"
+)
+
+func main() {    
+    client := redis.NewClient(&redis.Options{
+        Addr:	  "localhost:6379",
+        Password: "", // No password set
+        DB:		  0,  // Use default DB
+        Protocol: 2,  // Connection protocol
+    })
+}
+```
+
+You can also connect using a connection string:
+
+```go
+opt, err := redis.ParseURL("redis://<user>:<pass>@localhost:6379/<db>")
+if err != nil {
+	panic(err)
+}
+
+client := redis.NewClient(opt)
+```
+
+After connecting, you can test the connection by  storing and retrieving
+a simple [string]({{< relref "/develop/data-types/strings" >}}):
+
+```go
+ctx := context.Background()
+
+err := client.Set(ctx, "foo", "bar", 0).Err()
+if err != nil {
+    panic(err)
+}
+
+val, err := client.Get(ctx, "foo").Result()
+if err != nil {
+    panic(err)
+}
+fmt.Println("foo", val)
+```
+
+## Connect to a Redis cluster
+
+To connect to a Redis cluster, use `NewClusterClient()`. You can specify
+one or more cluster endpoints with the `Addrs` option:
+
+```go
+client := redis.NewClusterClient(&redis.ClusterOptions{
+    Addrs: []string{":16379", ":16380", ":16381", ":16382", ":16383", ":16384"},
+
+    // To route commands by latency or randomly, enable one of the following.
+    //RouteByLatency: true,
+    //RouteRandomly: true,
+})
+```
+
+## Connect to your production Redis with TLS
+
+When you deploy your application, use TLS and follow the
+[Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines.
+
+Establish a secure connection with your Redis database:
+
+```go
+// Load client cert
+cert, err := tls.LoadX509KeyPair("redis_user.crt", "redis_user_private.key")
+if err != nil {
+    log.Fatal(err)
+}
+
+// Load CA cert
+caCert, err := os.ReadFile("redis_ca.pem")
+if err != nil {
+    log.Fatal(err)
+}
+caCertPool := x509.NewCertPool()
+caCertPool.AppendCertsFromPEM(caCert)
+
+client := redis.NewClient(&redis.Options{
+    Addr:     "my-redis.cloud.redislabs.com:6379",
+    Username: "default", // use your Redis user. More info https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/
+    Password: "secret", // use your Redis password
+    TLSConfig: &tls.Config{
+        MinVersion:   tls.VersionTLS12,
+        Certificates: []tls.Certificate{cert},
+        RootCAs:      caCertPool,
+    },
+})
+
+//send SET command
+err = client.Set(ctx, "foo", "bar", 0).Err()
+if err != nil {
+    panic(err)
+}
+
+//send GET command and print the value
+val, err := client.Get(ctx, "foo").Result()
+if err != nil {
+    panic(err)
+}
+fmt.Println("foo", val)
+```