Sealos

https://sealos.io/docs/
Admin
Sealos is a cloud-native development platform that unifies the entire dev-to-prod lifecycle,...
Tokens:56,088
Snippets:604
Trust Score:9.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install System Dependencies

Source: https://sealos.io/docs/guides/databases/kafka/php

Install the necessary system-level library for Kafka communication.

```bash
sudo apt-get update
sudo apt-get install -y librdkafka-dev
```

--------------------------------

### Install psycopg2-binary

Source: https://sealos.io/docs/guides/databases/postgresql/python

Install the PostgreSQL adapter for Python using pip.

```bash
pip install psycopg2-binary
```

--------------------------------

### Configure entrypoint.sh

Source: https://sealos.io/docs/guides/devbox/entrypoint-sh

Example content for entrypoint.sh showing how to launch different types of applications.

```bash
#!/bin/bash
# Next.js
NODE_ENV=production node .next/standalone/server.js
 
# TypeScript Node.js
node dist/main.js
 
# Go
./main
```

--------------------------------

### Execute Redis Stack Examples

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Commands to run the provided RedisJSON and RediSearch example scripts.

```bash
node examples/redis-json.js
```

```bash
node examples/redis-search.js
```

--------------------------------

### Install Redis and Dotenv Packages

Source: https://sealos.io/docs/guides/databases/redis/python

Install the required Python client and environment variable loader.

```bash
pip install redis python-dotenv
```

--------------------------------

### Execute Redis Examples

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Commands to run the leaderboard and task queue demonstration scripts.

```bash
node examples/leaderboard.js
```

```bash
node examples/task-queue.js
```

--------------------------------

### Install PHP Kafka Extension

Source: https://sealos.io/docs/guides/databases/kafka/php

Install and enable the rdkafka extension for PHP.

```bash
sudo pecl install rdkafka
sudo sh -c 'echo "extension=rdkafka.so" > /etc/php/*/mods-available/rdkafka.ini'
sudo phpenmod rdkafka
```

--------------------------------

### Install Project Dependencies

Source: https://sealos.io/docs/examples/build-your-own-discord-bot

Initialize a new Node.js project and install the necessary packages for Discord interaction and API requests.

```bash
npm init -y
npm install discord.js axios dotenv
```

--------------------------------

### Start the Bot

Source: https://sealos.io/docs/examples/build-your-own-discord-bot

Command to launch the application.

```bash
npm start
```

--------------------------------

### Install PostgreSQL dependencies

Source: https://sealos.io/docs/guides/databases/postgresql/nodejs

Install the pg client and dotenv for environment variable management.

```bash
npm install pg dotenv
```

--------------------------------

### Startup commands for pre-built web applications

Source: https://sealos.io/docs/guides/devbox/entrypoint-sh

Use these commands in entrypoint.sh to start pre-built web applications like Next.js, Vue, or React.

```bash
#!/bin/bash
# Next.js (pre-built)
NODE_ENV=production node .next/standalone/server.js
 
# Vue (pre-built)
node server/index.js
 
# React (pre-built)
serve -s build -l 3000
```

--------------------------------

### Implement Milvus operations in Go

Source: https://sealos.io/docs/guides/databases/milvus/go

A complete example demonstrating how to connect to Milvus, define a schema, create a collection, and manage partitions.

```go
package main
 
import (
	"context"
	"log"
	"os"
	"strconv"
	"time"
 
	"github.com/joho/godotenv"
	"github.com/milvus-io/milvus-sdk-go/v2/client"
	"github.com/milvus-io/milvus-sdk-go/v2/entity"
)
 
func main() {
	// Load environment variables from .env file
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}
 
	// Get configuration from environment variables
	milvusAddr := os.Getenv("MILVUS_ADDR")
	collectionName := os.Getenv("COLLECTION_NAME")
	dimStr := os.Getenv("DIMENSION")
	idCol := os.Getenv("ID_COLUMN")
	embeddingCol := os.Getenv("EMBEDDING_COLUMN")
 
	// Convert dimension to int64
	dim, err := strconv.ParseInt(dimStr, 10, 64)
	if err != nil {
		log.Fatalf("Failed to parse DIMENSION: %v", err)
	}
 
	// Setup context for client creation, use 10 seconds here
	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()
 
	// Create a new Milvus client
	c, err := client.NewClient(ctx, client.Config{
		Address: milvusAddr,
	})
	if err != nil {
		log.Fatal("failed to connect to milvus:", err.Error())
	}
 
	// Check if the collection exists
	collExists, err := c.HasCollection(ctx, collectionName)
	if err != nil {
		log.Fatal("failed to check collection exists:", err.Error())
	}
	if collExists {
		// Drop the old collection if it exists
		_ = c.DropCollection(ctx, collectionName)
	}
 
	// Define collection schema
	schema := entity.NewSchema().WithName(collectionName).WithDescription("this is the basic example collection").
		WithField(entity.NewField().WithName(idCol).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(false)).
		WithField(entity.NewField().WithName(embeddingCol).WithDataType(entity.FieldTypeFloatVector).WithDim(dim))
 
	// Create the collection
	err = c.CreateCollection(ctx, schema, entity.DefaultShardNumber)
	if err != nil {
		log.Fatal("failed to create collection:", err.Error())
	}
 
	// List all collections
	collections, err := c.ListCollections(ctx)
	if err != nil {
		log.Fatal("failed to list collections:", err.Error())
	}
	for _, collection := range collections {
		log.Printf("Collection id: %d, name: %s\n", collection.ID, collection.Name)
	}
 
	// Show collection partitions
	partitions, err := c.ShowPartitions(ctx, collectionName)
	if err != nil {
		log.Fatal("failed to show partitions:", err.Error())
	}
	for _, partition := range partitions {
		log.Printf("partition id: %d, name: %s\n", partition.ID, partition.Name)
	}
 
	// Create a new partition
	partitionName := "new_partition"
	err = c.CreatePartition(ctx, collectionName, partitionName)
	if err != nil {
		log.Fatal("failed to create partition:", err.Error())
	}
 
	log.Println("After create partition")
	// Show collection partitions again to check creation
	partitions, err = c.ShowPartitions(ctx, collectionName)
	if err != nil {
		log.Fatal("failed to show partitions:", err.Error())
	}
	for _, partition := range partitions {
		log.Printf("partition id: %d, name: %s\n", partition.ID, partition.Name)
	}
 
	// Clean up by dropping the collection
	_ = c.DropCollection(ctx, collectionName)
	c.Close()
}
```

--------------------------------

### Install Milvus Go dependencies

Source: https://sealos.io/docs/guides/databases/milvus/go

Run these commands in your terminal to install the Milvus SDK and the godotenv package.

```bash
go get github.com/milvus-io/milvus-sdk-go/v2
go get github.com/joho/godotenv
```

--------------------------------

### Implement Redis Connection in Go

Source: https://sealos.io/docs/guides/databases/redis/go

A complete example showing how to load environment variables, initialize a Redis client, perform basic operations, and close the connection.

```go
package main
 
import (
	"fmt"
	"log"
	"os"
 
	"github.com/go-redis/redis"
	"github.com/joho/godotenv"
)
 
func main() {
	// Load environment variables from .env file
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}
 
	// Create a new Redis client
	client := redis.NewClient(&redis.Options{
		Addr:     fmt.Sprintf("%s:%s", os.Getenv("REDIS_HOST"), os.Getenv("REDIS_PORT")),
		Password: os.Getenv("REDIS_PASSWORD"),
		DB:       0, // use default DB
	})
	// Test the connection
	pong, err := client.Ping().Result()
	if err != nil {
		log.Fatal("Could not connect to Redis: ", err)
	}
	fmt.Println("Connected to Redis: ", pong)
	// Set a key
	err = client.Set("mykey", "Hello from Sealos DevBox!", 0).Err()
	if err != nil {
		log.Fatal("Could not set key: ", err)
	}
	// Get a key
	val, err := client.Get("mykey").Result()
	if err != nil {
		log.Fatal("Could not get key: ", err)
	}
	fmt.Println("mykey:", val)
 
	// Close the connection
	err = client.Close()
	if err != nil {
		log.Fatal("Error closing Redis connection: ", err)
	}
	fmt.Println("Redis connection closed successfully")
}
```

--------------------------------

### Install MySQL dependencies

Source: https://sealos.io/docs/guides/databases/mysql/nodejs

Install the mysql2 client and dotenv package for environment variable management.

```bash
npm install mysql2 dotenv
```

--------------------------------

### Install PostgreSQL and Environment Packages

Source: https://sealos.io/docs/guides/databases/postgresql/go

Install the required PostgreSQL driver and environment variable loader in your terminal.

```bash
go get github.com/lib/pq
go get github.com/joho/godotenv
```

--------------------------------

### Start Development Server

Source: https://sealos.io/docs/guides/devbox/develop

Command to initiate the development server for a Next.js application within the terminal.

```bash
npm run dev
```

--------------------------------

### Execute Redis Example Scripts

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Shell commands to run various Redis integration tests and examples.

```bash
# Test connection
node tests/connection-test.js
 
# Basic operations
node examples/basic-operations.js
 
# Advanced data structures
node examples/leaderboard.js
node examples/task-queue.js
 
# Caching patterns
node examples/cache-patterns.js
 
# Redis Stack features (if available)
node examples/redis-json.js
node examples/redis-search.js
 
# Connection pooling (v5+ features)
node examples/connection-pool.js
 
# Complete application
node examples/complete-app.js
```

--------------------------------

### Implement PostgreSQL Database Operations in Go

Source: https://sealos.io/docs/guides/databases/postgresql/go

A complete example demonstrating how to connect to PostgreSQL, create a table, insert data, and query records using the database/sql package.

```go
package main
 
import (
	"database/sql"
	"fmt"
	"log"
	"os"
 
	"github.com/joho/godotenv"
	_ "github.com/lib/pq"
)
 
// Employee struct represents the structure of our data
type Employee struct {
	ID       int
	Name     string
	Position string
}
 
// connectDB establishes a connection to the PostgreSQL database
func connectDB() (*sql.DB, error) {
	// Load environment variables from .env file
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}
 
	// Retrieve database connection details from environment variables
	dbHost := os.Getenv("DB_HOST")
	dbPort := os.Getenv("DB_PORT")
	dbUser := os.Getenv("DB_USER")
	dbPassword := os.Getenv("DB_PASSWORD")
	dbName := os.Getenv("DB_NAME")
 
	// Construct the connection string
	connStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
		dbHost, dbPort, dbUser, dbPassword, dbName)
 
	// Open a connection to the database
	db, err := sql.Open("postgres", connStr)
	if err != nil {
		return nil, err
	}
 
	// Verify the connection
	err = db.Ping()
	if err != nil {
		return nil, err
	}
 
	fmt.Println("Successfully connected to the database")
	return db, nil
}
 
// createTable creates the employees table if it doesn't exist
func createTable(db *sql.DB) error {
	_, err := db.Exec(`
		CREATE TABLE IF NOT EXISTS employees (
			id SERIAL PRIMARY KEY,
			name VARCHAR(100) NOT NULL,
			position VARCHAR(100) NOT NULL
		)
	`)
	return err
}
 
// insertEmployee inserts a new employee into the database
func insertEmployee(db *sql.DB, name, position string) error {
	_, err := db.Exec("INSERT INTO employees (name, position) VALUES ($1, $2)", name, position)
	return err
}
 
// getEmployees retrieves all employees from the database
func getEmployees(db *sql.DB) ([]Employee, error) {
	rows, err := db.Query("SELECT id, name, position FROM employees")
	if err != nil {
		return nil, err
	}
	defer rows.Close()
 
	var employees []Employee
	for rows.Next() {
		var emp Employee
		err := rows.Scan(&emp.ID, &emp.Name, &emp.Position)
		if err != nil {
			return nil, err
		}
		employees = append(employees, emp)
	}
	return employees, nil
}
 
func main() {
	// Connect to the database
	db, err := connectDB()
	if err != nil {
		log.Fatal(err)
	}
	// Ensure the database connection is closed when the function exits
	defer func() {
		if err := db.Close(); err != nil {
			log.Printf("Error closing database connection: %v", err)
		} else {
			fmt.Println("Database connection closed successfully")
		}
	}()
 
	// Create the employees table
	err = createTable(db)
	if err != nil {
		log.Fatal(err)
	}
 
	// Insert sample employees
	err = insertEmployee(db, "John Doe", "Developer")
	if err != nil {
		log.Fatal(err)
	}
 
	err = insertEmployee(db, "Jane Smith", "Designer")
	if err != nil {
		log.Fatal(err)
	}
 
	// Retrieve and display all employees
	employees, err := getEmployees(db)
	if err != nil {
		log.Fatal(err)
	}
 
	fmt.Println("Employees:")
	for _, emp := range employees {
		fmt.Printf("ID: %d, Name: %s, Position: %s\n", emp.ID, emp.Name, emp.Position)
	}
 
	// The database connection will be closed automatically when main() exits
	// due to the defer statement at the beginning of the function
}
```

--------------------------------

### Install Kafka Go dependencies

Source: https://sealos.io/docs/guides/databases/kafka/go

Install the required Go packages for Kafka connectivity using the terminal.

```bash
go get github.com/joho/godotenv
go get github.com/confluentinc/confluent-kafka-go/v2/kafka
```

--------------------------------

### Implement MongoDB connection and operations in Go

Source: https://sealos.io/docs/guides/databases/mongodb/go

A complete example showing how to load environment variables, connect to MongoDB, ensure the database exists, and perform basic CRUD operations.

```go
package main
 
import (
	"context"
	"fmt"
	"log"
	"os"
	"time"
 
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
 
// Employee struct represents the structure of our data
type Employee struct {
	Name     string
	Position string
}
 
func main() {
	// Load environment variables from .env file
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}
 
	// Get MongoDB connection URI and database name from environment variables
	mongoURI := os.Getenv("MONGO_URI")
	dbName := os.Getenv("DB_NAME")
 
	// Create a new client and connect to the server
	client, err := mongo.NewClient(options.Client().ApplyURI(mongoURI))
	if err != nil {
		log.Fatal(err)
	}
 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
 
	err = client.Connect(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Disconnect(ctx)
 
	// Check if the database exists, if not create it
	err = createDatabaseIfNotExists(client, ctx, dbName)
	if err != nil {
		log.Fatal(err)
	}
 
	// Get a handle for your collection
	collection := client.Database(dbName).Collection("employees")
 
	// Insert a document
	employee := Employee{"John Doe", "Developer"}
	insertResult, err := collection.InsertOne(ctx, employee)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Inserted a single document: ", insertResult.InsertedID)
 
	// Find a document
	var result Employee
	err = collection.FindOne(ctx, bson.M{"name": "John Doe"}).Decode(&result)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Found a single document: %+v\n", result)
}
 
func createDatabaseIfNotExists(client *mongo.Client, ctx context.Context, dbName string) error {
	// List all database names
	databases, err := client.ListDatabaseNames(ctx, bson.M{})
	if err != nil {
		return err
	}
 
	// Check if our database exists
	for _, db := range databases {
		if db == dbName {
			fmt.Printf("Database '%s' already exists\n", dbName)
			return nil
		}
	}
 
	// If the database doesn't exist, create it by inserting a document
	fmt.Printf("Creating database '%s'\n", dbName)
	err = client.Database(dbName).RunCommand(ctx, bson.D{{"create", "employees"}}).Err()
	if err != nil {
		return err
	}
 
	fmt.Printf("Database '%s' created successfully\n", dbName)
	return nil
}
```

--------------------------------

### Implement MongoDB connection and operations in main.rs

Source: https://sealos.io/docs/guides/databases/mongodb/rust

This example demonstrates initializing the MongoDB client, inserting a document, and querying a collection using the Tokio runtime.

```rust
use mongodb::{Client, options::ClientOptions};
use mongodb::bson::doc;
use dotenv::dotenv;
use std::env;
use serde::{Serialize, Deserialize};
use futures_util::stream::TryStreamExt;
 
#[derive(Debug, Serialize, Deserialize)]
struct Employee {
    name: String,
    position: String,
}
 
#[tokio::main]
async fn main() -> mongodb::error::Result<()> {
    // Load environment variables from .env file
    dotenv().ok();
 
    // Get the MongoDB URI from the environment
    let mongodb_uri = env::var("MONGODB_URI").expect("MONGODB_URI must be set");
 
    // Parse a connection string into an options struct
    let mut client_options = ClientOptions::parse(mongodb_uri).await?;
 
    // Manually set an option
    client_options.app_name = Some("Sealos DevBox Rust App".to_string());
 
    // Get a handle to the deployment
    let client = Client::with_options(client_options)?;
 
    // Get a handle to the database specified in the connection string
    let db = client.default_database()
        .expect("No default database found in the connection string");
 
    // Get a handle to a collection in the database
    let collection = db.collection::<Employee>("employees");
 
    // Insert a document
    let new_employee = Employee {
        name: "John Doe".to_string(),
        position: "Developer".to_string(),
    };
    let insert_result = collection.insert_one(new_employee).await?;
    println!("Inserted document with ID: {:?}", insert_result.inserted_id);
 
    // Query the documents in the collection
    let mut cursor = collection.find(doc! {}).await?;
 
    // Iterate over the results of the cursor
    while let Some(employee) = cursor.try_next().await? {
        println!("Found employee: {:?}", employee);
    }
 
    Ok(())
}
```

--------------------------------

### Install KafkaJS and Dotenv

Source: https://sealos.io/docs/guides/databases/kafka/nodejs

Install the required packages for Kafka communication and environment variable management.

```bash
npm install kafkajs dotenv
```

--------------------------------

### Install PHP MySQL Extension

Source: https://sealos.io/docs/guides/databases/mysql/php

Run these commands in the terminal to install the required MySQL driver for PHP.

```bash
sudo apt-get update
sudo apt-get install php-mysql -y
```

--------------------------------

### Install PHP PostgreSQL Extension

Source: https://sealos.io/docs/guides/databases/postgresql/php

Run these commands in the terminal to install the required PostgreSQL driver for PHP.

```bash
sudo apt-get update
sudo apt-get install php-pgsql
```

--------------------------------

### Install Redis Dependencies

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Install the required Redis client libraries and utilities via npm.

```bash
npm install redis dotenv @redis/json @redis/search @redis/time-series msgpack5
```

--------------------------------

### Install PHP Redis Extension

Source: https://sealos.io/docs/guides/databases/redis/php

Commands to update package lists and install the php-redis extension on the system.

```bash
sudo apt-get update
sudo apt-get install php-redis -y
```

--------------------------------

### Install MySQL and Dotenv Packages

Source: https://sealos.io/docs/guides/databases/mysql/go

Run these commands in your terminal to install the MySQL driver and environment variable loader.

```bash
go get github.com/go-sql-driver/mysql
go get github.com/joho/godotenv
```

--------------------------------

### Install Redis and Dotenv Packages

Source: https://sealos.io/docs/guides/databases/redis/go

Run these commands in your terminal to install the required Go dependencies for Redis connectivity and environment variable management.

```bash
go get github.com/go-redis/redis
go get github.com/joho/godotenv
```

--------------------------------

### Install MongoDB Go dependencies

Source: https://sealos.io/docs/guides/databases/mongodb/go

Run these commands in your terminal to install the official MongoDB driver and the godotenv package.

```bash
go get go.mongodb.org/mongo-driver/mongo
go get github.com/joho/godotenv
```

--------------------------------

### Install Milvus SDK and dotenv

Source: https://sealos.io/docs/guides/databases/milvus/nodejs

Install the official Milvus Node.js SDK and the dotenv package for environment variable management.

```bash
npm install @zilliz/milvus2-sdk-node dotenv
```

--------------------------------

### Implement Kafka producer and consumer in Rust

Source: https://sealos.io/docs/guides/databases/kafka/rust

A complete example demonstrating how to initialize a producer, send a message, and consume messages from a Kafka topic using rdkafka.

```rust
use rdkafka::config::ClientConfig;
use rdkafka::producer::{FutureProducer, FutureRecord};
use rdkafka::consumer::{StreamConsumer, Consumer};
use rdkafka::message::Message;
use std::time::Duration;
use dotenv::dotenv;
use std::env;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();
 
    let brokers = env::var("KAFKA_BROKERS").expect("KAFKA_BROKERS must be set");
    let topic = env::var("KAFKA_TOPIC").expect("KAFKA_TOPIC must be set");
    let group_id = env::var("KAFKA_GROUP_ID").expect("KAFKA_GROUP_ID must be set");
 
    // Producer setup
    let producer: FutureProducer = ClientConfig::new()
        .set("group.id", &group_id)
        .set("bootstrap.servers", &brokers)
        .set("message.timeout.ms", "5000")
        .create()?;
 
    // Produce a message
    let delivery_status = producer
        .send(
            FutureRecord::to(&topic)
                .payload("Hello from Sealos DevBox!")
                .key("key"),
            Duration::from_secs(0),
        )
        .await;
 
    println!("Delivery status: {:?}", delivery_status);
 
    // Add a delay to ensure the message is processed
    tokio::time::sleep(Duration::from_secs(1)).await;
 
    // Consumer setup
    let consumer: StreamConsumer = ClientConfig::new()
        .set("group.id", "rust-consumer-group")
        .set("bootstrap.servers", &brokers)
        .set("enable.partition.eof", "false")
        .set("session.timeout.ms", "6000")
        .set("enable.auto.commit", "true")
        .set("auto.offset.reset", "earliest")  // Add this line
        .create()?;
 
    consumer.subscribe(&[&topic])?;
 
    // Consume messages
    println!("Waiting for messages...");
    let mut message_count = 0;
    let max_messages = 5;  // Set the maximum number of messages to receive
    
    while message_count < max_messages {
        match tokio::time::timeout(Duration::from_secs(5), consumer.recv()).await {
            Ok(Ok(msg)) => {
                println!("Received message: {:?}", msg.payload_view::<str>());
                message_count += 1;
            }
            Ok(Err(e)) => println!("Error while receiving message: {:?}", e),
            Err(_) => {
                println!("No more messages received after {} seconds. Exiting.", 5);
                break;
            }
        }
    }
    
    println!("Received {} messages in total.", message_count);
 
    Ok(())
}
```

--------------------------------

### Configure package.json

Source: https://sealos.io/docs/examples/build-your-own-discord-bot

Update the package configuration to support ES modules and define the start script.

```json
{
  "type": "module",
  "scripts": {
    "start": "node src/index.js"
  }
}
```

--------------------------------

### Optimize Data Structures

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Examples of using efficient Redis commands like INCR and hSet for better performance.

```javascript
// Use appropriate data types
// For counters: use INCR instead of GET/SET
await client.incr('page_views');
 
// For bulk data: use HMSET instead of multiple SET
await client.hSet('user:1001', {
  name: 'John',
  email: 'john@example.com',
  age: '30'
});
```

--------------------------------

### Use Pipelining for Bulk Operations

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Example of using multi/exec pipelining to reduce round-trip time for bulk operations.

```javascript
// Instead of multiple individual commands
const pipeline = client.multi();
for (let i = 0; i < 1000; i++) {
  pipeline.set(`key:${i}`, `value:${i}`);
}
await pipeline.exec();
```

--------------------------------

### Identify WRONGPASS Authentication Error

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Example of the error message received when authentication fails.

```text
ReplyError: WRONGPASS invalid username-password pair
```

--------------------------------

### Identify ECONNREFUSED Error

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Example of the error message received when the client cannot connect to the Redis server.

```text
Error: connect ECONNREFUSED 127.0.0.1:6379
```

--------------------------------

### Identify Socket Closed Error

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Example of the error message received when the socket connection is unexpectedly terminated.

```text
Error: Socket closed unexpectedly
```

--------------------------------

### Execute Main Script

Source: https://sealos.io/docs/guides/databases/milvus/nodejs

Demonstrate the workflow by creating a collection, inserting sample data, and performing a search.

```javascript
const { createCollection, insertData, search } = require('./milvusOperations');
 
async function main() {
  try {
    // Create collection
    await createCollection();
 
    // Generate sample vectors and metadata
    const sampleVectors = [
      new Array(128).fill(0).map(() => Math.random()),
      new Array(128).fill(0).map(() => Math.random())
    ];
    const sampleMetadata = ['Sample 1', 'Sample 2'];
 
    // Insert data
    await insertData(sampleVectors, sampleMetadata);
 
    // Perform search
    const queryVector = new Array(128).fill(0).map(() => Math.random());
    await search(queryVector, 2);
 
  } catch (error) {
    console.error('An error occurred:', error);
  }
}
 
main();
```

--------------------------------

### Initialize Project Structure

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Create the necessary directories and files for the Node.js Redis project.

```bash
# Create directories
mkdir src examples tests
 
# Create main files
touch .env package.json
touch src/redisClient.js
touch examples/basic-operations.js
touch tests/connection-test.js
```

--------------------------------

### Install MongoDB PHP Library

Source: https://sealos.io/docs/guides/databases/mongodb/php

Use Composer to install the official MongoDB PHP library.

```bash
composer require mongodb/mongodb
```

--------------------------------

### Install MongoDB dependencies

Source: https://sealos.io/docs/guides/databases/mongodb/nodejs

Install the official MongoDB driver and dotenv for environment variable management.

```bash
npm install mongodb dotenv
```

--------------------------------

### Install Kafka Python Dependencies

Source: https://sealos.io/docs/guides/databases/kafka/python

Installs the kafka-python client and python-dotenv for environment variable management.

```bash
pip install kafka-python python-dotenv
```

--------------------------------

### Startup commands for compiled backend services

Source: https://sealos.io/docs/guides/devbox/entrypoint-sh

Use these commands to execute compiled binaries or packaged JAR files.

```bash
#!/bin/bash
# Go (compiled)
./main
 
# Java (packaged)
java -jar app.jar
 
# Rust (compiled)
./server
```

--------------------------------

### Startup commands for interpreted backend services

Source: https://sealos.io/docs/guides/devbox/entrypoint-sh

Use these commands to run interpreted languages like Python, Node.js, or PHP.

```bash
#!/bin/bash
# Python
python app.py
 
# Node.js (pre-built)
node dist/index.js
 
# PHP
php -S 0.0.0.0:8000
```

--------------------------------

### Install MongoDB PHP Extension

Source: https://sealos.io/docs/guides/databases/mongodb/php

Use the PECL command to install the MongoDB extension for PHP in the terminal.

```bash
sudo pecl install mongodb
```

--------------------------------

### Run Connection Pool Demo

Source: https://sealos.io/docs/guides/databases/redis/nodejs

Command to execute the connection pool demonstration script.

```bash
node examples/connection-pool.js
```

--------------------------------

### Implement Database Operations in main.rs

Source: https://sealos.io/docs/guides/databases/postgresql/rust

Establish a connection pool, create a table, insert data, and query records using sqlx.

```rust
use sqlx::postgres::PgPoolOptions;
use sqlx::Row;
use dotenv::dotenv;
use std::env;
 
#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    // Load environment variables from .env file
    dotenv().ok();
 
    // Get the database URL from the environment
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
 
    // Create a connection pool
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;
 
    // Create the employees table if it doesn't exist
    sqlx::query(
        r#"
        CREATE TABLE IF NOT EXISTS employees (
            id SERIAL PRIMARY KEY,
            name VARCHAR(100) NOT NULL,
            position VARCHAR(100) NOT NULL
        )
        "#,
    )
    .execute(&pool)
    .await?;
 
    println!("Table created successfully");
 
    // Insert a sample employee
    let new_employee = sqlx::query(
        r#"
        INSERT INTO employees (name, position)
        VALUES ($1, $2)
        RETURNING id, name, position
        "#,
    )
    .bind("John Doe")
    .bind("Developer")
    .fetch_one(&pool)
    .await?;
 
    println!(
        "Inserted employee: ID: {}, Name: {}, Position: {}",
        new_employee.get::<i32, _>("id"),
        new_employee.get::<String, _>("name"),
        new_employee.get::<String, _>("position")
    );
 
    // Query all employees
    let employees = sqlx::query("SELECT id, name, position FROM employees")
        .fetch_all(&pool)
        .await?;
 
    println!("All employees:");
    for employee in employees {
        println!(
            "ID: {}, Name: {}, Position: {}",
            employee.get::<i32, _>("id"),
            employee.get::<String, _>("name"),
            employee.get::<String, _>("position")
        );
    }
 
    Ok(())
}
```

--------------------------------

### Initialize Maven Project

Source: https://sealos.io/docs/guides/databases/mongodb/java

Commands to generate a new Maven project structure and move files to the root directory.

```bash
mvn archetype:generate -DgroupId=com.example -DartifactId=mongodb-java-example -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
mv mongodb-java-example/* .
rm -rf mongodb-java-example/
```

--------------------------------

### Install Python MySQL Dependencies

Source: https://sealos.io/docs/guides/databases/mysql/python

Install the official MySQL connector and the dotenv package for environment variable management.

```bash
pip install mysql-connector-python python-dotenv
```

--------------------------------

### Configure PostgreSQL client

Source: https://sealos.io/docs/guides/databases/postgresql/nodejs

Initialize the PostgreSQL client using configuration values loaded from environment variables.

```javascript
const { Client } = require('pg');
require('dotenv').config();
 
const dbConfig = {
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  host: process.env.DB_HOST,
  port: process.env.DB_PORT,
  database: process.env.DB_NAME,
};
 
const client = new Client(dbConfig);
```

--------------------------------

### Create a Kafka Consumer in Java

Source: https://sealos.io/docs/guides/databases/kafka/java

Shows how to initialize a Kafka consumer, subscribe to a topic, and continuously poll for new messages.

```java
package com.example;
 
import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.serialization.StringDeserializer;
 
import java.time.Duration;
import java.util.Collections;
import java.util.Properties;
 
public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = loadConfig();
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
 
        Consumer<String, String> consumer = new KafkaConsumer<>(props);
 
        String topic = props.getProperty("topic");
        consumer.subscribe(Collections.singletonList(topic));
 
        try {
            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                for (ConsumerRecord<String, String> record : records) {
                    System.out.println("Received message: " + record.value() +
                            " from topic: " + record.topic() +
                            ", partition: " + record.partition() +
                            ", offset: " + record.offset());
                }
            }
        } finally {
            consumer.close();
        }
    }
 
    private static Properties loadConfig() {
        Properties props = new Properties();
        try (FileInputStream fis = new FileInputStream("src/main/resources/kafka.properties")) {
            props.load(fis);
        } catch (IOException e) {
            throw new RuntimeException("Error loading Kafka configuration", e);
        }
        return props;
    }
}
```

--------------------------------

### Initialize Maven Project

Source: https://sealos.io/docs/guides/databases/kafka/java

Commands to generate a new Maven project structure and clean up the default test directory.

```bash
mvn archetype:generate -DgroupId=com.example -DartifactId=kafka-java-example -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
mv kafka-java-example/* .
rm -rf kafka-java-example
rm -rf test
```
Tokens:
Raw