Микросервисы: подключение к базам данных из приложений на Python, Go и JavaScript

MySQL

Для работы с MySQL существует официальный драйвер MySQL Connector.

1) Для начала установим драйвер при помощи менеджера пакетов pip:

pip install mysql-connector-python

2) Далее инициализируем новое соединение к серверу MySQL. Импортируем библиотеку mysql.connector и отдельно класс Error который в случае проблем с подключением будет выводить конкретную ошибку.

Создаем функцию с именем create_connection в которую передадим значения адреса БД (host), имени пользователя (user) и пароля пользователя (password). Чтобы произвести соединение создадим класс create_connection в который передадим имена переменных в которых хранятся данные для подключения к баз данных:

import mysql.connector
from mysql.connector import Error

def create_connection(host_name, user_name, user_password):
    connection = None
    try:
        connection = mysql.connector.connect(
            host="194.87.190.137",
            user="gen_user",
            password="m-EE6Wm}z@wCKe"
        )
        print("Successfully connected to MySQL Server!")
    except Error as e:
        print(f"The error '{e}' occurred")
    return connection

def execute_query(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        connection.commit()
        print("Query executed successfully")
    except Error as e:
        print(f"The error '{e}' occurred")

connection = create_connection("194.87.190.137", "gen_user", "m-EE6Wm}z@wCKe")

3) Запускаем скрипт. При успешном соединение с MySQL будет выведено сообщение «Successfully connected to MySQL Server!».

При наличие ошибок будет выведен код и описание ошибки.

4) Создадим новую таблицу. Подключаемся к базе данных используя класс connection.database в котором указываем имя базы данных. БД должна уже быть предварительно создана.

Для создания таблицы инициализируем переменную create_table_query в которой указываем SQL запрос CREATE TABLE. Для вставки данных инициализируем другую переменную insert_data_query в которой будет указан SQL запрос INSERT INTO. Для выполнения каждого запроса используется класс execute_query который принимает строку с соединением к БД и имя переменной с SQL запросом: 

connection.database = 'test_db'

create_table_query = """
CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    age INT NOT NULL
)
"""
execute_query(connection, create_table_query)

insert_data_query = """
INSERT INTO users (name, age) VALUES 
('Alice', 30),
('Bob', 25)
"""
execute_query(connection, insert_data_query)

if connection.is_connected():
    connection.close()
    print("Connection closed")

5) Запускаем скрипт:

Как можно увидеть данные были успешно созданы.

PostgreSQL

Для Python разработано несколько плагинов, которые позволяют подключить PostgreSQL, однако самым популярным является psycopg2, который мы и будем использовать.

Psycopg2 — это один из самых часто используемых плагинов для подключения СУБД PostgreSQL. Одним из преимуществ Psycopg2 является поддержка многопоточности — при инициализации соединения к базе данных оно будет поддерживается несколькими потоками. 

1) Установка плагина происходит при помощи пакетного менеджера pip (должен быть установлен заранее):

pip install psycopg2-binary

2) Произведем подключение к PostgreSQL. Для этого импортируем пакет psycopg2, далее создадим функцию create_new_conn, в которой используем метод try. Подключение осуществляется при помощи функции psycopg2.connect, которая во входных данных принимает имя базы данных, имя пользователя, пароль пользователя и адрес базы данных. Для инициализации соединения к PostgreSQL используется функция create_new_conn(). Полный исходный код для подключения к базе данных представлен ниже:

import psycopg2

from psycopg2 import OperationalError

def create_new_conn():
    conn_to_postgres = None
    while not conn_to_postgres:
        try:
            conn_to_postgres = psycopg2.connect(
                default_db="default_db",
                default_user="gen_user",
                password_for_default_user="PasswordForDefautUser9893#",
                db_address="147.45.249.142"
            )
            print("The connection to PostgreSQL has been successfully established!")
        except OperationalError as e:
            print(e)
    return conn_to_postgres

conn_to_postgres = create_new_conn()

Запускаем скрипт:

python3 connect_to_postgres.py

Если соединение будет установлено успешно, появится сообщение:

The connection to PostgreSQL has been successfully established!

Следующим шагом создадим новую таблицу с именем books в которой будет три столбца. Для использования SQL выражений применяют класс cursor например, на создание объектов. Если в запросе были добавлены или изменены данные, то после запроса необходимо указать функцию conn_to_postgres.commit(), которая применяет внесенные изменения. Код для создания таблицы представле далее:

import psycopg2

from psycopg2 import OperationalError

def create_new_conn():
    conn_to_postgres = None
    while not conn_to_postgres:
        try:
            conn_to_postgres = psycopg2.connect(
                default_db="default_db",
                default_user="gen_user",
                password_for_default_user="PasswordForDefautUser9893#",
                db_address="147.45.249.142"
            )
        except OperationalError as e:
            print(e)
    return conn_to_postgres

conn_to_postgres = create_new_conn()

cursor = conn_to_postgres.cursor()

cursor.execute("""
CREATE TABLE books
(
    book_id INT  PRIMARY KEY NOT NULL,
    book_name VARCHAR(255) NOT NULL,
    book_author VARCHAR(255) NOT NULL
)
""")

conn_to_postgres.commit()
print("Table Created successfully")

Запускаем:

python3 create_table.py

Таблица была успешно создана. Далее выполним SQL-команду INSERT INTO для добавления новой строки:

cursor.execute("""
       INSERT INTO books (book_id,book_name,book_author) VALUES
(1, 'Long Walk to Freedom', 'Nelson_Mandela')
""")

Полный код:

import psycopg2

from psycopg2 import OperationalError

def create_new_conn():
    conn_to_postgres = None
    while not conn_to_postgres:
        try:
            conn_to_postgres = psycopg2.connect(
                default_db="default_db",
                default_user="gen_user",
                password_for_default_user="PasswordForDefautUser9893#",
                db_address="147.45.249.142"
            )
        except OperationalError as e:
            print(e)
    return conn_to_postgres

conn_to_postgres = create_new_conn()

cursor = conn_to_postgres.cursor()

cursor.execute("""
       INSERT INTO books (book_id,book_name,book_author) VALUES
(1, 'Long Walk to Freedom', 'Nelson_Mandela')
""")

conn_to_postgres.commit()
conn_to_postgres.close()
print("Data inserted successfully")

Выполним скрипт:

python3 insert-data.py

Redis

Redis относится к классу NoSQL СУБД, где данные хранятся в оперативной памяти, а не на жестких дисках. Для хранения данных в Redis используется формат ключ - значение. У Redis довольно широкий спектр применения, начиная от хранения данных заканчивая хранением кэша и использования в качестве брокера сообщений. 

В языке программирования Python используется библиотека redis-py (или просто redis). 

1) Для начала установим библиотеку redis:

pip install redis

2) Для того чтобы подключиться к инстансу Redis, воспользуемся структурой с использованием блока try, указав в нем функцию для подключения к Redis — redis.StrictRedis, где указывается адрес redis, порт и пароль пользователя:

import redis

try:
    connect_to_redis_server = redis.StrictRedis(
        redis_db_host=147.45.249.143,
        redis_db_port=6379,
        redis_user_password='PasswordForRedis6379')
    print connect_to_redis_server
    connect_to_redis_server.ping()
    print 'Successfully connected to Redis Server!'
except Exception as ex:
    print 'Error:', ex
    exit('Failed to connect to Redis server.')

Запустим скрипт:

python3 connect_to_redis.py

Если при запуске скрипта было выведено «Successfully connected to Redis Server!». значит, подключение к Redis было выполнено успешно.

Вместо хранения данных в таблицах Redis использует формат ключ — значение. Под ключом понимается способ, предназначенный для уникальной идентификации значения.

1) Сначала создадим новую запись в Redis используя класс set. В примере ниже создадим запись с ключом City и значением Berlin:

print ('Create new record:', connect_to_redis_server.set("City", "Berlin"))

2) Далее выведем значение ключа City, используя класс get:

print ('Print record using record key', connect_to_redis_server.get("City"))

3) Если запись необходимо удалить, то используется класс delete:  

('Delete record with key :', connect_to_redis_server.delete("City")

Полный фрагмент кода представлен ниже:

import redis

try:
    connect_to_redis_server = redis.StrictRedis(
        redis_db_host=147.45.249.143,
        redis_db_port=6379,
        redis_user_password='PasswordForRedis6379')

    print ('New record created:', connect_to_redis_server.set("City", "Berlin"))
    print ('Print created record using record key', connect_to_redis_server.get("City"))
    print ('Delete created record with key :', connect_to_redis_server.delete("City"))
except Exception as ex:
    print ('Error:', ex)

MongoDB

Еще одной популярной NoSQL СУБД является MongoDB которая относится к классу документоориентированных СУБД. Данные организованы в виде документов в формате JSON. 

Для работы с языком программирования Python можно воспользоваться PyMongo — синхронным API-плагином.

1) Установка плагина осуществляется при помощи команды:

pip3 install mongo

2) Импортируем модуль pymongo. Класс MongoClient используется для указания адреса СУБД. Подключимся к серверу mongodb, используя блок try. 

import pymongo

connect_to_mongo = pymongo.MongoClient("mongodb://147.45.249.145:27017/")

first_db = connect_to_mongo["mongo-db1"]

try:
  first_db.command("serverStatus")
except Exception as e:
  print(e)
else:
  print("Successfully connected to MongoDB Server!")

connect_to_mongo.close()

Запускаем:

python3 connect_mongodb.py

Если соединение было успешно установлено, скрипт вернет сообщение «Successfully connected to MongoDB Server!».

3) Для добавления данных в MongoDB необходимо создать словарь. Создадим словарь с именем record1, в котором будут присутствовать три ключа:

record1 = {
        "name": "Alex",
        "age": 25,
        "location": "Moscow"
        }

4) Чтобы добавить данные словаря, в mongo используется метод insert_one:

insertrecord = collection1.insert_one(record1)

По итогу код будет следующий:

import pymongo

connect_to_mongo = pymongo.MongoClient("mongodb://147.45.249.145:27017/")

db1 = connect_to_mongo["newdb"]
collection1 = db1["userdata"]


record1 = {
        "name": "Alex",
        "age": 25,
        "location": "Moscow"
        }

insertrecord = collection1.insert_one(record1)

print(insertrecord)

Запустим скрипт:

python3 connect_mongodb.py

ClickHouse

ClickHouse представляет собой столбцовую или колоночную NoSQL базу данных в которой данные хранятся в столбцах а не в строках как это реализовано в традиционных реляционных базах данных. Широко используется для работы с аналитическими запросами.

1) Для Python разработан специальный плагин для работы с ClickHouse — clickhouse-driver. Установим драйвер при помощи менеджера пакетов pip:

pip install clickhouse-driver

2) Чтобы инициализировать новое соединение с ClickHouse необходимо импортировать класс Client из библиотеки clickhouse_drive. 

Для использования SQL запросов применяется функция client.execute. Дополнительно необходимо задать движок. Более подробно с поддерживаемыми движками в ClickHouse можно ознакомиться по ссылке. Воспользуемся движком по умолчанию — MergeTree. Создадим новую таблицу users в которую добавим два столбца с данными. Для перечисления данных которые будут добавлены в таблицу используется тип данных «кортеж». После того как необходимые запросы будут выполнены, необходимо закрыть соединение с СУБД при помощи класса client.disconnect(). Итоговый код будет следующим:

from clickhouse_driver import Client

client = Client(host=194.87.190.138',
                user='root',
                password='P@$$w0rd123',
                port=9000)

client.execute('''
CREATE TABLE IF NOT EXISTS Users (
    id UInt32,
    name String,
) ENGINE = MergeTree()
ORDER BY id
''')

data = [
    (1, 'Alex'),
    (2, 'Tim')
]

client.execute('INSERT INTO Users (id, name) VALUES', data)
result = client.execute('SELECT * FROM Users')

for row in result:
    print(row)
client.disconnect()

MySQL

Для работы с СУБД MySQL в Go используется драйвер go-sql-driver/mysql.

1) Создаем новый каталог, в котором будут храниться файлы проекта, и переходим в него: 

mkdirmysql-connect && cd mysql-connect

2) Создаем файл go.mod, в котором будут храниться зависимости:

go mod init golang-connect-mysql

3) Скачиваем драйвер mysql при помощи команды go get:

go get -u github.com/go-sql-driver/mysql

4) Создаем новый файл с именем main.go Данные для подключения к СУБД указаны в переменной dsn:

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

func main() {
    dsn := "root:password@tcp(localhost:3306)/testdb"

    db, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    if err := db.Ping(); err != nil {
        log.Fatal(err)
    }

    fmt.Println("Successfully connected to the database!")

    query := "INSERT INTO users (name, age) VALUES (?, ?)"

    result, err := db.Exec(query, "Alex", 25)
    if err != nil {
        log.Fatal(err)
    }

    lastInsertID, err := result.LastInsertId()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Inserted data with ID: %d\n", lastInsertID)
}

PostgreSQL

Для того чтобы подключиться к PostgreSQL, был разработан драйвер pq. Перед тем как установить драйвер, подготовим нашу среду.

1) Создаем новый каталог, в котором будут храниться файлы проекта, и переходим в него: 

mkdir postgres-connect && cd postgres-connect

2) Так как мы будем работать с зависимостями, нам необходимо создать файл go.mod, в котором они хранятся:

go mod init golang-connect-postgres

3) Скачиваем драйвер pq при помощи команды go get:

go get github.com/lib/pq

4) Создаем новый файл с именем main.go Помимо импортирования библиотеки pq, также необходимо добавить библиотеку для работы с базами данных (database/sql) т.к. по-умолчанию Go не поставляется с официальными драйверами для баз данных. Библиотека database/sql состоит из общих, независимых интерфейсов для работы с базами данных. Также стоит обратить внимание на символ нижнего подчеркивания (пустого идентификатора) при импорте модуля pq:

_ "github.com/lib/pq"

Пустой идентификатор используется во избежание ошибки «unused import» (неиспользуемый импорт), поскольку в данном случае нам потребуется только регистрация драйвера в database/sql.

Пакет fmt необходим для вывода данных в стандартный поток вывода, например, в консоль. Чтобы открыть соединение с базой данных, необходимо использовать функцию sql.Open, в которую передается строка с подключением (connStr) и имя драйвера — postgres. В строке подключения задается имя пользователя, имя базы данных, пароль и адрес хоста:

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/lib/pq"
)

func main() {
    connStr := "user=golang dbname=db_for_golang password=Golanguserfordb0206$ host=47.45.249.146 sslmode=disable"

    db, err := sql.Open("postgres", connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    err = db.Ping()
    if err != nil {
        log.Fatal(err)
    }
     fmt.Println("Successfully connected to PostgreSQL!")
}

Скомпилируем и запустим программу:

go run main.go

Если соединение было установлено успешно, то в терминале отобразится сообщение Successfully connected to PostgreSQL!.

1) Теперь рассмотрим пример, как можно вставить данные в таблицу. Но сначала создадим таблицу в базе данных. Для этого воспользуемся строкой подключения к базе данных PostgreSQL которая отображается в разделе «Подключения» в веб-интерфейсе Timeweb Cloud. Убедитесь заранее что на вашем устройстве установлена клиентская утилита postgresql-client. Входим в оболочку psql и подключаемся к ранее созданной базе данных:

\c db_for_golang

2) Создаем таблицу с именем Cities, в которой будет три поля — city_id, city_name и city_population:

CREATE TABLE Cities (
city_id INT PRIMARY KEY,
city_name VARCHAR(45) NOT NULL,
city_population INT NOT NULL);

3) Выдаем полные права на созданную таблицу для пользователя:

GRANT ALL PRIVILEGES ON TABLE cities TO golang;

4) Функция db.Prepare используется для подготовки данных В ней заранее указывается необходимый запрос на вставку. Для вставки данных используется функция stmt.Exec, где перечислены необходимые данные. В языке Go принято использовать чистый SQL без использования подхода ORM (Object-Relational Mapping — объектно-реляционное отображение):

stmt, err := db.Prepare("INSERT INTO Cities(city_id, city_name, city_population) VALUES($1, $2, $3)")
    if err != nil {
        log.Fatal(err)
    }
    defer stmt.Close()

    _, err = stmt.Exec(1, "Toronto", 279435)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Data inserted successfully!")
}

При успешной вставке данных в консоль будет выведено сообщение Data inserted successfully!:

Redis

Для подключения Redis необходимо воспользоваться драйвером go-redis.

1) По аналогии с подключением к PostgreSQL создаем новую директорию:

mkdir connect-to-redis && cd connect-to-redis

2) Подготавливаем файл с зависимостями:

go mod init golang-connect-redis

И оптимизируем их:

go mod tidy

3) Скачиваем модуль go-redis:

go get github.com/go-redis/redis/v8

4) Для подключения к Redis используется функция redis.Options, в которой задаются адрес и порт Redis-сервера. Так как по умолчанию в Redis не используется аутентификация, то поле Password можно оставить пустым, в качестве используемой базы данных можно выбрать стандартную базу, используемую по умолчанию (база 0):

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/go-redis/redis/v8"
)

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr:     "147.45.249.147:6379",
        Password: "",
        DB:       0,
    })

    ctx := context.Background()

    _, err := rdb.Ping(ctx).Result()
    if err != nil {
        log.Fatalf("Couldn't connect to Redis: %v", err)
    }
    fmt.Println("Successfully connected to Redis!")

}

При успешном подключении будет выведено сообщение «Successfully connected to Redis!»:

MongoDB

Для работы с MongoDB используется соответствующий драйвер. 

1) Создаем новую директорию, в которой будет храниться структура проекта:

mkdir connect-to-mongodb && cd connect-to-mongodb

2) Инициализируем файл с зависимостями:

go mod init golang-connect-mongodb

3) Скачиваем библиотеку mongo:

go get go.mongodb.org/mongo-driver/mongo

4) Подключение к MongoDB осуществляется при помощи метода options.Client().ApplyURI, который принимает строку подключения вида mongodb://147.45.249.148:27017, где 147.45.249.148 — адрес сервера MongoDB, а 27017 —  порт для подключения к MongoDB. Строка options.Client().ApplyURI используется только для указания данных для подключения. Чтобы проверить статус соединения можно воспользоваться другой функцией — client.Ping, которая отображает успешный или неуспешный статус подключения:

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
    clientOptions := options.Client().ApplyURI("mongodb://147.45.249.147:27017")

    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatalf("Couldn't connect to MongoDB server: %v", err)
    }
    fmt.Println("successfully connected to MongoDB!")

    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatalf("Could not ping MongoDB server: %v", err)
    }
    fmt.Println("Ping MongoDB server successfully!")

}

Если при запуске соединение было успешно установлено, то в терминале будут выведены сообщения:

successfully connected to MongoDB!
Ping MongoDB server successfully

В своей работе MongoDB использует коллекции для хранения данных. Для создания коллекций используется функция .Collection. Далее мы создадим базу данных first-database и коллекцию first-collection. В коллекции будет создан новый документ, в котором будут находиться три ключа — user-name, user-age и user-email:

collection := client.Database("first-database").Collection("first-collection")

document := map[string]interface{}{
        "user-name":  "Alex",
        "user-age":   25,
        "user-email": "alex@corporate.com",
    }

    insertResult, err := collection.InsertOne(ctx, document)
    if err != nil {
        log.Fatalf("Couldn't insert new document: %v", err)
    }
    fmt.Printf("Inserted new document with ID: %v\n", insertResult.InsertedID)

    if err := client.Disconnect(ctx); err != nil {
        log.Fatalf("Could not disconnect from MongoDB: %v", err)
    }
    fmt.Println("Disconnected from MongoDB!")
}

При успешном выполнении запроса в терминале отобразится сообщение Inserted new document with ID с уникальным идентификатором документа:

ClickHouse

Для работы с колоночной СУБД ClickHouse используется драйвер clickhouse-go.

1) Создаем новый каталог, в котором будут храниться файлы проекта, и переходим в него: 

clickhouse-connect && cd clickhouse-connect

2) Создаем файл go.mod, в котором будут храниться зависимости:

go mod init golang-connect-clickhouse

3) Скачиваем драйвер Clickhouse при помощи команды go get:

go get github.com/ClickHouse/clickhouse-go/v2

4) Создаем новый файл с именем main.go в котором указываем данные для подключения к ClickHouse:

package main

import (
    "database/sql"
    "log"

    "github.com/ClickHouse/clickhouse-go/v2"
)

func main() {
    dsn := "tcp://localhost:9000?username=user1&password=PasswordForuser175465&database=new_db"

    db, err := sql.Open("clickhouse", dsn)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    if err := db.Ping(); err != nil {
        log.Fatal(err)
    }

    log.Println("Connected to ClickHouse!")
}

MySQL

Для работы с MySQL используется драйвер mysql2. 

1) Создаем директорию в которой будем хранить файлы проекта:

mkdir js-mysql-connect && cd js-mysql-connect

2) Инициализируем проект:

npm init -y

3) Устанавливаем библиотеку mysql2:

npm install mysql2

4) Для подключения к СУБД MySQL используем следующий код:

const mysql = require('mysql2');

const connection_to_mysql = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: 'PasswordForRoot74463',
  database: db1,
});

connection_to_mysql.connect((err) => {
  if (err) {
    console.error('Error connecting to MySQL:', err.message);
    return;
  }
  console.log('Successfully connected to MySQL Server!');

    connection_to_mysql.end((endErr) => {
      if (endErr) {
        console.error('Error closing the connection_to_mysql:', endErr.message);
      } else {
        console.log('Connection closed.');
      }
    });
  });

PostgreSQL

Подключение к СУБД PostgreSQL осуществляется при помощи библиотеки pg.

1) Создаем директорию в которой будем хранить файлы проекта:

mkdir js-postgres-connect && cd js-postgres-connect

2) Инициализируем проект:

npm init -y

3) Устанавливаем библиотеку pg:

npm install pg

4) Для подключения к PostgreSQL сначала импортируем библиотеку pg далее создаем константу в которой укажем переменные для адреса БД, имя пользователя, пароль пользователя, имя БД и порт БД. Подключение осуществляется при помощи класса new pg.Client в котором передаются данные для подключения.

Также создадим таблицу cities в которую будут добавлены 2 записи. Для этого используется функция queryDatabase в которой указываются SQL запросы:

const pg = require('pg');

const config = {
  postgresql_server_host: '193.160.208.190',
  postgresql_user: 'gen_user',
  postgresql_user_password: 'PasswordForGenUser56467$',
  postgresql_database_name: 'default_db',
  postgresql_database_port: 5432,
};

const client = new pg.Client(config);

client.connect(err => {
    if (err) throw err;
    else {
        queryDatabase();
    }
});

function queryDatabase() {
    const query = `
        DROP TABLE IF EXISTS cities;
        CREATE TABLE cities (id serial PRIMARY KEY, name VARCHAR(80), population INTEGER);
        INSERT INTO cities (name, population) VALUES ('Berlin', 3645000);
        INSERT INTO cities (name, population) VALUES ('Paris', 2161000);
    `;

    client
        .query(query)
        .then(() => {
            console.log('Table created successfully!');
            client.end(console.log('Closed client connection'));
        })
        .catch(err => console.log(err))
        .then(() => {
            console.log('Finished execution, exiting now');
            process.exit();
        });
}

5) Для запуска файла используем команду:

node connect-to-postgres.js

Как можно увидеть на скриншоте выше, подключение к PostgreSQL прошло успешно. Также была создана таблица и две записи.

Redis

Для работы с Redis используется библиотека ioredis.

1) Создаем директорию в которой будем хранить файлы проекта:

mkdir js-redis-connect && cd js-redis-connect

2) Инициализируем проект:

npm init -y

3) Устанавливаем библиотеку ioredis:

npm install ioredis

4) Для подключения Redis импортируем библиотеку ioredis.

Далее создаем константу с именем redis и укажем адрес сервера Redis. 

Вставка данных, то есть создания объектов типа «ключ - значение» осуществляется при помощи асинхронной функции с именем setData которая принимает на себя два значения — key и value что соответствует формату данных системы Redis.

const Redis = require('ioredis');

const redis = new Redis({
  host: '147.45.153.210',
  port: 6379,
  password: 'UY+p8e?Kxmqqfa',
});

async function setData(key, value) {
  try {
    await redis.set(key, value);
    console.log('Data successfully set');
  } catch (error) {
    console.error('Error setting data:', error);
  }
}

async function getData(key) {
  try {
    const value = await redis.get(key);
    console.log('Data retrieved');
    return value;
  } catch (error) {
    console.error('Error getting data:', error);
  }
}

(async () => {
  await redis.select(1);

  await setData('user', 'alex');
  await getData('user');

  redis.disconnect();
})();

5) Запускаем:

node connect-to-redis.js

Соединение с сервером Redis а также создания ключа с значением произошло успешно.

MongoDB

Для работы с MongoDB используется драйвер mongodb.

1) Создаем директорию в которой будем хранить файлы проекта:

mkdir js-mongodb-connect && cd js-mongodb-connect

2) Инициализируем проект:

npm init -y

3) Устанавливаем библиотеку mongodb:

npm install mongodb

4) Для подключения MongoDB импортируем библиотеку mongodb. Адрес СУБД указывается в константе uri далее адрес передается в классе MongoClient:

const { MongoClient } = require('mongodb');

const uri = "mongodb://194.87.190.137:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });

async function connectToDatabase() {
  try {
    await client.connect();
    console.log("Successfully connected to MongoDB!");

    const database = client.db("myDatabase");
    const collection = database.collection("myCollection");

      const documents = await collection.find({}).toArray();
    console.log("Documents found:", documents);
  } catch (error) {
    console.error("Error connecting to MongoDB:", error);
  } finally {
    await client.close();
    console.log("Connection closed.");
  }
}

connectToDatabase();

ClickHouse

Для работы с ClickHouse используется драйвер clickhouse/client.

1) Создаем директорию в которой будем хранить файлы проекта:

mkdir js-clickhouse-connect && cd js-clickhouse-connect

2) Инициализируем проект:

npm init -y

3) Устанавливаем библиотеку @clickhouse/client:

npm install @clickhouse/client

4) Для подключения к ClickHouse используем код ниже в котором зададим данные для подключения и выполним простой SQL запрос которые вернет первые 10 записей из системной таблицы с именем system.tables:

const { ClickHouse } = require('@clickhouse/client');

const client = new ClickHouse({
  host: 'http://localhost:8123',
  username: 'default',         
  password: 'PasswordforDefaultUser45435',                
  database: 'default',
});

async function connectAndQuery() {
  try {
    console.log('Successfully connected to ClickHouse Server!');

    const rows = await client.query({
      query: 'SELECT * FROM system.tables LIMIT 10',
      format: 'JSON',
    }).then((result) => result.json());

    console.log('Query results:', rows);
  } catch (error) {
    console.error('Error Successfully connected to ClickHouse Server! or running the query:', error);
  } finally {
    console.log('Done.');
  }
}

connectAndQuery();