Quick start

This guide will go over setting up a simple developement environment connected to a Valkey Docker instance.

Understanding GLIDE Clients

GLIDE provides two main client types:

• GlideClient: For standalone Valkey instances.
• GlideClusterClient: For cluster deployments.

For this guide, we will use a standalone client to connect to a Valkey Docker instance.

Setting Up

1. Follow the instructions on the Docker website to install Docker for your operating system.

2. Start a local Valkey server:

   # Pull and run Valkey server
   docker run -d --name valkey-server -p 6379:6379 valkey/valkey:latest
   
   # Verify it's running
   docker ps

3. Verify connection with Valkey server:

   docker exec valkey-server valkey-cli ping
   # Expected output: PONG

4. Install Valkey GLIDE

   Python

   # Install the latest version
   pip3 install valkey-glide

   Java

   // Add to your `pom.xml`
   <dependencies>
       <dependency>
           <groupId>io.valkey</groupId>
           <artifactId>valkey-glide</artifactId>
           <version>2.0.1</version>
       </dependency>
   </dependencies>

   Node.js

   # GLIDE includes TypeScript definitions out of the box.
   npm install @valkey/valkey-glide

   Go

   # Initialize a new Go module (if needed)
   go mod init your-project-name
   
   # Install GLIDE
   go get github.com/valkey-io/valkey-glide/go

5. Finally, conect to Valkey using GLIDE and verify your installation.

   Python

    import asyncio
    from glide import GlideClient, NodeAddress
   
    async def main():
        # Create client configuration
        client = GlideClient([NodeAddress("localhost", 6379)])
   
        try:
            # Test the connection
            response = await client.ping()
   
            # Valkey respond with PONG
            print(f"Connected! Server responded: {response}")
   
        except Exception as e:
            print(f"Connection failed: {e}")
   
        finally:
            # Always close the client
            await client.close()
   
    # Run the async function
    if __name__ == "__main__":
        asyncio.run(main())

   Java

      import glide.api.GlideClient;
      import glide.api.models.configuration.GlideClientConfiguration;
      import glide.api.models.configuration.NodeAddress;
   
      public class ConnectionTest {
          public static void main(String[] args) {
              // Create client configuration
              GlideClientConfiguration config = GlideClientConfiguration.builder()
                  .address(NodeAddress.builder()
                      .host("localhost")
                      .port(6379)
                      .build())
                  .build();
   
              try (GlideClient client = GlideClient.createClient(config).get()) {
                  // Test the connection
                  String response = client.ping().get();
   
                  // Valkey respond with PONG
                  System.out.println("Connected! Server responded: " + response);
   
              } catch (Exception e) {
                  System.err.println("Connection failed: " + e.getMessage());
              }
          }
      }

   Node.js

      const { GlideClient } = require('@valkey/valkey-glide');
   
      async function main() {
          // Create client configuration
          const client = GlideClient.createClient({
              addresses: [{ host: 'localhost', port: 6379 }]
          });
   
          try {
              // Test the connection
              const response = await client.ping();
   
              // Valkey respond with PONG
              console.log(`Connected! Server responded: ${response}`);
   
          } catch (error) {
              console.error(`Connection failed: ${error.message}`);
          } finally {
              // Always close the client
              client.close();
          }
      }
   
      // Run the function
      main().catch(console.error);

   Go

      package main
   
      import (
          "fmt"
          "log"
   
          "github.com/valkey-io/valkey-glide/go/glide/api"
      )
   
      func main() {
          // Create client configuration
          config := &api.GlideClientConfiguration{
              Addresses: []api.NodeAddress{
                  {Host: "localhost", Port: 6379},
              },
          }
   
          client := api.NewGlideClient(config)
          defer client.Close()
   
          // Test the connection
          response, err := client.Ping()
          if err != nil {
              log.Fatalf("Connection failed: %v", err)
          }
   
          // Valkey respond with PONG
          fmt.Printf("Connected! Server responded: %s\n", response)
      }

   Caution

   Always close() GLIDE clients to cleanup resources when the instance is no longer needed.

6. Running the above snippet should give you this respond.

   Connected! Server responded: PONG

Connection Configuration

GLIDE offers many configuration options. A typical configuration may look like following:

Python

import asyncio
from glide import GlideClient, NodeAddress, GlideClientConfiguration

async def main():
    # Setting up connection configuration
    config = GlideClientConfiguration(
        addresses=[NodeAddress("localhost", 6379)],
        # Connection timeout (milliseconds)
        request_timeout=5000,
        # Connection pool size
        connection_backoff_max_delay=1000,
        # TLS configuration (if needed)
        use_tls=False,
        # Database selection (0-15 for Redis/Valkey)
        database_id=0
    )

    client = GlideClient(config)

    try:
        # Test connection with custom message
        response = await client.ping("Hello GLIDE!")
        print(f"Server responded: {response}")

    finally:
        await client.close()

if __name__ == "__main__":
    asyncio.run(main())

Java

import glide.api.GlideClient;
import glide.api.models.configuration.GlideClientConfiguration;
import glide.api.models.configuration.NodeAddress;
import java.time.Duration;

public class AdvancedConnection {
    public static void main(String[] args) {
        // Setting up connection configuration
        GlideClientConfiguration config = GlideClientConfiguration.builder()
            .address(NodeAddress.builder()
                .host("localhost")
                .port(6379)
                .build())
            // Connection timeout
            .requestTimeout(Duration.ofSeconds(5))
            // TLS configuration (if needed)
            .useTls(false)
            // Database selection
            .databaseId(0)
            .build();

        try (GlideClient client = GlideClient.createClient(config).get()) {
            // Test connection with custom message
            String response = client.ping("Hello GLIDE!").get();
            System.out.println("Server responded: " + response);

        } catch (Exception e) {
            System.err.println("Connection failed: " + e.getMessage());
        }
    }
}

Node.js

const { GlideClient } = require('@valkey/valkey-glide');

async function main() {
    // Setting up connection configuration
    const configs = {
        addresses: [{ host: 'localhost', port: 6379 }],
        // Connection timeout (milliseconds)
        requestTimeout: 5000,
        // TLS configuration (if needed)
        useTls: false,
        // Database selection (0-15 for Redis/Valkey)
        databaseId: 0
    }

    const client = GlideClient.createClient(configs);

    try {
        // Test connection with custom message
        const response = await client.ping('Hello GLIDE!');
        console.log(`Server responded: ${response}`);

    } finally {
        client.close();
    }
}

main().catch(console.error);

Go

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/valkey-io/valkey-glide/go/glide/api"
)

func main() {
    // Setting up connection configuration
    config := &api.GlideClientConfiguration{
        Addresses: []api.NodeAddress{
            {Host: "localhost", Port: 6379},
        },
        // Connection timeout
        RequestTimeout: 5 * time.Second,
        // TLS configuration (if needed)
        UseTls: false,
        // Database selection
        DatabaseId: 0,
    }

    client := api.NewGlideClient(config)
    defer client.Close()

    // Test connection with custom message
    response, err := client.PingWithMessage("Hello GLIDE!")
    if err != nil {
        log.Fatalf("Connection failed: %v", err)
    }

    fmt.Printf("Server responded: %s\n", response)
}

Tip

For a full list of connection options, take a look at the connection options reference.

Next Steps

Congratulations, you are now connected to Valkey using GLIDE! To see how to make basic operations take a look at the our guide.