sponge

Use gtls to establish a mutual TLS (two-way) secure gRPC connection where both the server and the client verify each other using a common Certificate Authority (CA).

On the server side, use GetServerTLSCredentialsByCA providing the CA certificate, the server certificate, and the server key.

On the client side, use GetClientTLSCredentialsByCA providing the target server name, the CA certificate, the client certificate, and the client key.

// Server side
import "github.com/go-dev-frame/sponge/pkg/grpc/gtls"

credentials, err := gtls.GetServerTLSCredentialsByCA(
    certfile.Path("two-way/ca.pem"),
    certfile.Path("two-way/server/server.pem"),
    certfile.Path("two-way/server/server.key"),
)
server := grpc.NewServer(grpc.Creds(credentials))

// Client side
import "github.com/go-dev-frame/sponge/pkg/grpc/gtls"

credentials, err := gtls.GetClientTLSCredentialsByCA(
    "localhost",
    certfile.Path("two-way/ca.pem"),
    certfile.Path("two-way/client/client.pem"),
    certfile.Path("two-way/client/client.key"),
)
conn, err := grpc.NewClient("127.0.0.1:8080", grpc.WithTransportCredentials(credentials))

The client package provides a simplified way to establish gRPC connections in Go. Use client.NewClient(address, ...options) to create a connection. The function accepts several functional options to configure the client, including:

• client.WithServiceDiscover(discovery, isPrimary): Configures service discovery.
• client.WithLoadBalance(): Enables load balancing.
• client.WithSecure(credentials): Configures secure connections using provided credentials.
• client.WithUnaryInterceptor(unaryInterceptors...): Adds unary interceptors.
• client.WithStreamInterceptor(streamInterceptors...): Adds stream interceptors.

Once a connection (conn) is established, you can use it to initialize your generated gRPC client stubs.

package main

import (
    "context"
    "fmt"
    "github.com/go-dev-frame/sponge/pkg/grpc/client"
    pb "google.golang.org/grpc/examples/helloworld/helloworld"
)

func main() {
    // Initialize the connection with an address and optional configuration
    conn, err := client.NewClient("127.0.0.1:8282",
        // client.WithServiceDiscover(getDiscovery(), false),
        // client.WithLoadBalance(),
        // client.WithSecure(credentials),
        // client.WithUnaryInterceptor(unaryInterceptors...),
        // client.WithStreamInterceptor(streamInterceptors...),
    )
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    // Use the connection to create a service client
    greeterClient := pb.NewGreeterClient(conn)
    reply, err := greeterClient.SayHello(context.Background(), &pb.HelloRequest{Name: "Alice"})
    if err != nil {
        panic(err)
    }
    fmt.Printf("Greeting: %s\n", reply.GetMessage())
}

Sponge can be installed on Windows using an integrated installation package or via native Go installation.

Prerequisites

• Go Version: Requires Go 1.23+.
• GOBIN Configuration: Ensure GOBIN is set and added to your system PATH. You can check this with go env GOBIN.

Method 1: Integrated Installation Package (Recommended)

1. Download the integrated package (contains all dependencies) from Baidu Netdisk or Lanzou Cloud (Password: 5rq9).
2. Unzip the package and run install.bat.
3. Important: Always use Git Bash to run Sponge commands. Do not use the default Windows cmd terminal, as it may result in 'command not found' errors.
4. Open Git Bash (Right-click → Open Git Bash here) and run:

   sponge init          # Initialize and install dependencies
   sponge plugins       # View installed plugins
   sponge -v            # Check version

Method 2: Native Installation

Follow the standard Go installation procedure for Sponge as described in the official documentation.