How to connect MongoDB , golang in Kubernetes

The database and the server are not connected.
Attempting to deploy in Kubernetes environment.

this is deployment, sevice of mongodb , golang http server

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
  labels:
    app: backend
spec:
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - image: royroyee/backend:0.8
        name: backend
        ports:
        - containerPort: 9001

---
apiVersion: v1
kind: Service
metadata:
  name: backend-service
  labels:
    run: backend-service
spec:
  ports:
    - port: 9001
      targetPort: 9001
      protocol: TCP
  selector:
    app: backend
  type: NodePort
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mongo
  labels:
    app: mongo
spec:
  selector:
    matchLabels:
      app: mongo
  template:
    metadata:
      labels:
        app: mongo
    spec:
      containers:
      - image: mongo
        name: mongo-db
        ports:
        - containerPort: 27017
---
apiVersion: v1
kind: Service
metadata:
  name: mongo-service
  labels:
    run: mongo-service
spec:
  ports:
    - port: 27017
      targetPort: 27017
      protocol: TCP
  selector:
    app: mongo

and my golang code ...
mongodb session

func getSession() *mgo.Session {
	s, err := mgo.Dial("mongodb://mongo-service:27017/mongo-db")

pls let me know ..

also I tried something like this.

// mongodb://mongo-service:27017/backend
// mongodb://mongo-service:27017/mongo-db
// mongodb://mongo-service:27017

To connect MongoDB with Golang in a Kubernetes environment, you need to follow these steps:

Deploy MongoDB as a statefulset or a deployment in your Kubernetes cluster.

Create a Service for MongoDB to access the deployed pods from your Golang application.

In your Golang application, use the official MongoDB Go driver to establish a connection to the MongoDB service by specifying the service name and port.

Verify the connection by running a simple test that inserts and retrieves data from the MongoDB database.

Finally, package the Golang application as a Docker image and deploy it as a deployment in the same Kubernetes cluster.

Here is a sample Go code to connect to MongoDB:

package main

import (
	"context"
	"fmt"
	"log"

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

func main() {
	// Set client options
	clientOptions := options.Client().ApplyURI("mongodb://mongodb-service:27017")

	// Connect to MongoDB
	client, err := mongo.Connect(context.TODO(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	// Check the connection
	err = client.Ping(context.TODO(), nil)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Connected to MongoDB!")
}

Here's a sample YAML file for deploying MongoDB as a StatefulSet and a Go application as a Deployment:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongodb
spec:
  serviceName: mongodb-service
  replicas: 1
  selector:
    matchLabels:
      app: mongodb
  template:
    metadata:
      labels:
        app: mongodb
    spec:
      containers:
        - name: mongodb
          image: mongo:4.4
          ports:
            - containerPort: 27017
          volumeMounts:
            - name: mongodb-data
              mountPath: /data/db
  volumeClaimTemplates:
    - metadata:
      name: mongodb-data
      annotations:
        volume.beta.kubernetes.io/storage-class: standard
      spec:
        accessModes: [ "ReadWriteOnce" ]
        resources:
          requests:
            storage: 1Gi

---
apiVersion: v1
kind: Service
metadata:
  name: mongodb-service
spec:
  selector:
    app: mongodb
  ports:
    - name: mongodb
      port: 27017
      targetPort: 27017
  clusterIP: None

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: go-app
  template:
    metadata:
      labels:
        app: go-app
    spec:
      containers:
        - name: go-app
          image: <your-go-app-image>
          ports:
            - containerPort: 8080

Note: You will need to replace your-go-app-image with the actual Docker image of your Go application.