diff --git a/.gitignore b/.gitignore
index bbfd2cb..37c7aee 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,4 +14,5 @@
 # Dependency directories (remove the comment below to include it)
 # vendor/
 
-.idea
\ No newline at end of file
+.idea
+*.pem
diff --git a/base64.go b/base64.go
new file mode 100644
index 0000000..260a517
--- /dev/null
+++ b/base64.go
@@ -0,0 +1,12 @@
+package mongodb
+
+import "encoding/base64"
+
+func base64DecodeToBytes(text string) []byte {
+	s, _ := base64.StdEncoding.DecodeString(text)
+	return s
+}
+
+func base64DecodeToString(text string) string {
+	return string(base64DecodeToBytes(text))
+}
diff --git a/mongodb.go b/mongodb.go
index 5741b17..f83c888 100644
--- a/mongodb.go
+++ b/mongodb.go
@@ -7,37 +7,97 @@ import (
 	"github.com/logrusorgru/aurora"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
+	"go.mongodb.org/mongo-driver/mongo/readpref"
 )
 
+// Config ...
+type Config struct {
+	Host   string
+	DBName string
+
+	TLS        *ConnectTLSOpts
+	Standalone *ConnectStandaloneOpts
+}
+
+// ConnectTLSOpts ...
+type ConnectTLSOpts struct {
+	ReplSet             string
+	CaFile              string
+	CertKeyFile         string
+	CertKeyFilePassword string
+}
+
+// ConnectStandaloneOpts ...
+type ConnectStandaloneOpts struct {
+	AuthMechanism string
+	AuthSource    string
+	Username      string
+	Password      string
+}
+
 var db *mongo.Database
 
 // Connect to mongo server
-func Connect(host, user, password, dbName, mechanism, source string) (*mongo.Database, error) {
+func Connect(cfg Config) (*mongo.Database, error) {
+	if cfg.TLS != nil && cfg.TLS.ReplSet != "" {
+		return connectWithTLS(cfg)
+	}
 	connectOptions := options.ClientOptions{}
+	opts := cfg.Standalone
 	// Set auth if existed
-	if user != "" && password != "" {
+	if opts.Username != "" && opts.Password != "" {
 		connectOptions.Auth = &options.Credential{
-			AuthMechanism: mechanism,
-			AuthSource:    source,
-			Username:      user,
-			Password:      password,
+			AuthMechanism: opts.AuthMechanism,
+			AuthSource:    opts.AuthSource,
+			Username:      opts.Username,
+			Password:      opts.Password,
 		}
 	}
 
 	// Connect
-	client, err := mongo.Connect(context.Background(), connectOptions.ApplyURI(host))
+	client, err := mongo.Connect(context.Background(), connectOptions.ApplyURI(cfg.Host))
 	if err != nil {
-		fmt.Println("Error when connect to MongoDB database", host, err)
+		fmt.Println("Error when connect to MongoDB database", cfg.Host, err)
 		return nil, err
 	}
 
-	fmt.Println(aurora.Green("*** CONNECTED TO MONGODB: " + host))
+	fmt.Println(aurora.Green("*** CONNECTED TO MONGODB: " + cfg.Host + " --- DB: " + cfg.DBName))
 
 	// Set data
-	db = client.Database(dbName)
+	db = client.Database(cfg.DBName)
 	return db, nil
 }
 
+func connectWithTLS(cfg Config) (*mongo.Database, error) {
+	ctx := context.Background()
+	opts := cfg.TLS
+
+	caFile, err := initFileFromBase64String("ca.pem", opts.CaFile)
+	if err != nil {
+		return nil, err
+	}
+	certFile, err := initFileFromBase64String("cert.pem", opts.CertKeyFile)
+	if err != nil {
+		return nil, err
+	}
+	pwd := base64DecodeToString(opts.CertKeyFilePassword)
+	s := "%s/?tls=true&tlsCAFile=./%s&tlsCertificateKeyFile=./%s&tlsCertificateKeyFilePassword=%s&authMechanism=MONGODB-X509"
+	uri := fmt.Sprintf(s, cfg.Host, caFile.Name(), certFile.Name(), pwd)
+	readPref := readpref.SecondaryPreferred()
+	clientOpts := options.Client().SetReadPreference(readPref).SetReplicaSet(opts.ReplSet).ApplyURI(uri)
+	client, err := mongo.Connect(ctx, clientOpts)
+	if err != nil {
+		return nil, err
+	}
+	if err := client.Ping(ctx, readpref.SecondaryPreferred()); err != nil {
+		return nil, err
+	}
+	db = client.Database(cfg.DBName)
+
+	fmt.Println(aurora.Green("*** CONNECTED TO MONGODB: " + cfg.Host + " --- DB: " + cfg.DBName))
+	return db, err
+}
+
 // GetInstance ...
 func GetInstance() *mongo.Database {
 	return db
diff --git a/mongodb_test.go b/mongodb_test.go
new file mode 100644
index 0000000..ae6273b
--- /dev/null
+++ b/mongodb_test.go
@@ -0,0 +1,47 @@
+package mongodb
+
+import (
+	"testing"
+
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+func Test_connectWithTLS(t *testing.T) {
+	type args struct {
+		cfg Config
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *mongo.Database
+		wantErr bool
+	}{
+		{
+			name: "should connect success",
+			args: args{
+				cfg: Config{
+					Host:   "mongodb://vps1:27017,vps2:27017,vps3:27017",
+					DBName: "unibag",
+					TLS: &ConnectTLSOpts{
+						ReplSet:             "sellyrs",
+						CaFile:              "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUQzRENDQXNTZ0F3SUJBZ0lVWllwWEJPK3JUTVFDOGJzc05UU1ljQU02cmxZd0RRWUpLb1pJaHZjTkFRRUwKQlFBd1lqRUxNQWtHQTFVRUF3d0NRMEV4RGpBTUJnTlZCQXNNQlUxUFRrZFBNUk13RVFZRFZRUUtEQXBDVlZOVQpSVVJYUVZKRk1SUXdFZ1lEVlFRSERBdFFRVWxPUlZOV1NVeE1SVEVMTUFrR0ExVUVDQXdDVDBneEN6QUpCZ05WCkJBWVRBbFZUTUI0WERUSXlNREl5TWpBME5UVXhOMW9YRFRNeU1ESXlNREEwTlRVeE4xb3dZakVMTUFrR0ExVUUKQXd3Q1EwRXhEakFNQmdOVkJBc01CVTFQVGtkUE1STXdFUVlEVlFRS0RBcENWVk5VUlVSWFFWSkZNUlF3RWdZRApWUVFIREF0UVFVbE9SVk5XU1V4TVJURUxNQWtHQTFVRUNBd0NUMGd4Q3pBSkJnTlZCQVlUQWxWVE1JSUJJakFOCkJna3Foa2lHOXcwQkFRRUZBQU9DQVE4QU1JSUJDZ0tDQVFFQTNmZi9ialdlRVVIRXRScGdDbi91TjFOQ1I4MjUKNFQvYThXcGJBdGtjSENwUWsyeThnKzV6dGNHWmpGcVNvREV1OWkxbzZSZHNISGpOWTdzdlM1U1ZMdkNWKy92eQpLUmZFMTlubGRrOG5TN3VsNW9zNFdXUUFxTGhJZDVQVG13c2N1OG01OFFNUmUxV0JhVjBObnNtREU3VVVnbjQrClNYa0t3aFo2VU9yNFlyTTNCTEplOGd2aHZpTGVYVU1VQVgrQlA3YUFOUHpFbHlManVXMUxzdzdoWTBTbDVETUEKc21LWjYycEZFamJlckJGNFBpdnZxNEx3ODBsN21Cd1lRcGxvWUpLSkNqRW93QmJhVk1hdnRuRmFNZ241TG8ySgptWkVIcWpGdVBGQnpzamxrMlZ5czE4dTgvZWlJOFEzQzNSdjk4aEkyMVp4MHJKQmc4YnB3cTJ6T1RRSURBUUFCCm80R0pNSUdHTUIwR0ExVWREZ1FXQkJTZHVKYitaam5HY2lDTTFLNGVQQ3pRbG0rdm96QWZCZ05WSFNNRUdEQVcKZ0JTZHVKYitaam5HY2lDTTFLNGVQQ3pRbG0rdm96QVBCZ05WSFJNQkFmOEVCVEFEQVFIL01ETUdBMVVkRVFRcwpNQ3FDQkhad2N6R0NCSFp3Y3pLQ0JIWndjek9IQk1Db0FVYUhCTUNvQVV1SEJNQ29BVWlIQk1Db0FZa3dEUVlKCktvWklodmNOQVFFTEJRQURnZ0VCQUlMaFVDM2k4NytFbk9NY1EvS3F2ZVpydGZ2dmZsVC9kUGNhcmIxYTg1ODgKUWVzVko2QmJnazhBZlBVQzlZZjNNL2dyS3l3ck9zVHZpVlRucXo5cWdvRUZwRVR6QldnYVNDTmFucXlEY3NrWAp4cW5JZzF1TTlvaTlOK3NxbGo3QU43NVFLRnhEQ0YwcHBJT056Y3BqbVFuWE5YMGt6L2hYS0pIQXZ3K25hMUtWCmpoT3hSMndlSDJ4SmFSSjFiNGV1U29Ca243c0QyT3MxN0VxbVArQW5RKzl3UzgyWkkwOW8zVDdPNFpVRVlsSDQKOThLbDBmT3k4djdvbGNiM05nTnM4NkxmVjd4cFVuOUY4b3lnaEo4bkNuMlFpMEZ0YzFpS1VTb2JoTS9wSTF4MApNRGJKSld6bUlOZjIyc2lWbkxWY01YTkQzVWo5bGtuelFoUFplTW93WG1jPQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0t",
+						CertKeyFile:         "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",
+						CertKeyFilePassword: "MTIzNDQzMjE=",
+					},
+					Standalone: nil,
+				},
+			},
+			want:    nil,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := connectWithTLS(tt.args.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("connectWithTLS() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+		})
+	}
+}
diff --git a/util.go b/util.go
new file mode 100644
index 0000000..6939507
--- /dev/null
+++ b/util.go
@@ -0,0 +1,21 @@
+package mongodb
+
+import (
+	"fmt"
+	"os"
+)
+
+func initFileFromBase64String(filename, value string) (*os.File, error) {
+	f, err := os.Create(filename)
+	if err != nil {
+		fmt.Println("mongodb.initFileFromBase64String - err: ", err)
+		return nil, err
+	}
+	b := base64DecodeToBytes(value)
+	if _, err := f.Write(b); err != nil {
+		fmt.Println("mongodb.initFileFromBase64String - write file err: ", err)
+		return nil, err
+	}
+	f.Sync()
+	return f, nil
+}