DEV Community: Ajinkya Ingole

Deploying docker-based CEPH cluster using ceph-ansible

Ajinkya Ingole — Sat, 02 May 2020 12:56:40 +0000

Why Docker and Ceph?

● Stateless containers
● Stateful data
● Location independent access
● Robust access protocols
● Massively scalable
● Open source

Install ansible

For installing ansible and configuring secret-free login between nodes, this is not covered here. Please refer to Official Documents at https://docs.ansible.com/
Releases
The following branches should be used depending on your requirements. The stable-* branches have been QE tested and sometimes recieve backport fixes throughout their lifecycle. The master branch should be considered experimental and used with caution.

stable-3.0 Supports Ceph versions jewel and luminous. This branch requires Ansible version 2.4.
stable-3.1 Supports Ceph versions luminous and mimic. This branch requires Ansible version 2.4.
stable-3.2 Supports Ceph versions luminous and mimic. This branch requires Ansible version 2.6.
stable-4.0 Supports Ceph version nautilus. This branch requires Ansible version 2.8.
stable-5.0 Supports Ceph version octopus. This branch requires Ansible version 2.9.
master Supports the master branch of Ceph. This branch requires Ansible version 2.9.

Download ceph-ansible

git clone https://github.com/ceph/ceph-ansible.git
cd ceph-ansible
# Refer to the official document of ceph-ansible http://docs.ceph.com/ceph-ansible/master for branch instructions.
# stable-3.1 Support for Ceph version luminous and mimic. This branch supports Ansible version 2.4.
git checkout stable-3.1

Configure ceph-ansible

cp group_vars/all.yml.sample group_vars/all.yml
cp group_vars/osds.yml.sample group_vars/osds.yml
cp site-docker.yml.sample site-docker.yml

Edit the group_vars/all.yml file. The following information should be adapted according to the actual situation.

generate_fsid: true
monitor_interface: eth0
journal_size: 5120
public_network: 10.0.0.0/24
cluster_network: 10.0.0.0/24
ceph_docker_image: "ceph/daemon"
ceph_docker_image_tag: latest-mimic
containerized_deployment: true
ceph_docker_registry: docker.io
radosgw_interface: eth0

Edit the group_vars/osds.yml file. The following information should be adapted according to the actual situation.

osd_scenario: collocated
devices:
  - /dev/xvdb
  - /dev/xvdc
  - /dev/xvdc

Edit the hosts file /etc.ansible/hosts, the following information should be adapted according to the actual situation.

[mons]
ip-10-0-0-80.ec2.internal

[mgrs]
ip-10-0-0-80.ec2.internal

[osds]
ip-10-0-0-80.ec2.internal 

[rgws]
ip-10-0-0-80.ec2.internal

Start deployment
If the following command fails, the log file defaults to / var/log/ansible.log, you can refer to the error log for processing. (Note: During deployment, docker will be installed by default on each node. This step script does not determine whether the current machine has docker installed. If the target machine has docker installed, there may be errors. The solution is to comment out the corresponding steps to install docker. The corresponding contents are roles/ceph-docker-common/tasks/pre_requisites/pre requisites. Ites.yml.)

ansible-playbook site-docker.yml

Output:

docker ps
docker exec d77bd7f96bfe ceph -s

I hope that you have understood how to deploy ceph in docker using ansible.

Happy Cephing!!

How to connect to your Kubernetes services using internal DNS

Ajinkya Ingole — Fri, 10 Apr 2020 08:43:08 +0000

Introduction

Kubernetes DNS schedules a DNS Pod and Service on the cluster, and configures the kubelets to tell individual containers to use the DNS Service’s IP to resolve DNS names.

What things get DNS names?

Every Service defined in the cluster (including the DNS server itself) is assigned a DNS name. By default, a client Pod’s DNS search list will include the Pod’s own namespace and the cluster’s default domain. This is best illustrated by example:

Assume a Service named foo in the Kubernetes namespace bar. A Pod running in namespace bar can look up this service by simply doing a DNS query for foo. A Pod running in namespace quux can look up this service by doing a DNS query for foo.bar.

To make these names resolvable you need a tool that watches the Kubernetes API so as to allow you to know your container IPs, and then answer your DNS requests with the correct IP. At present the most common tool to achieve this is Kube-DNS. I believe this is the first tool you should deploy in Kubernetes cluster.

This is what a basic Kubernetes Service for a HTTP server looks like:



kind: Service
apiVersion: v1
metadata:
  name: http-server
spec:
  selector:
    app: http-server
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80

Once this object is deployed in your cluster you should be able to contact the name http-server (from the same namespace), and Kube-DNS will answer with the correct ClusterIP to speak to your final pods. ClusterIPs are governed by IPTables rules created by kube-proxy on Workers that NAT your request to the final container’s IP.

The Kube-DNS naming convention is service.namespace.svc.cluster-domain.tld and the default cluster domain is cluster.local.
For example, if you want to contact a service called mysql in the db namespace from any namespace, you can simply speak to mysql.db.svc.cluster.local.

To practice what we have discussed we will see how to deploy a simple two service application, and how to connect them. In this case a Wordpress and a mysql application.

So let’s start by creating basic Kubernetes Service for a HTTP server



$ git clone https://github.com/ajinkyaingole30/kube-pod-connect-of-diff-namespace.git
$ cd kube-pod-connect-of-diff-namespace
$ kubectl create -f kube-dns.yml

To check service



$ kubectl get svc

NAME          TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
http-server   ClusterIP   10.102.105.197   <none>        80/TCP    11s

Now let's create namespace:



$ kubectl create ns mysql-example
$ kubectl create ns wordpress-example

Create mysql deployment resource



$ kubectl create -f mysql-deployment.yml

To allow any other container to speak to database pod we need to expose it to a service resource



$ kubectl create -f mysql-service.yml

Create Wordpress container and configure it to talk to Mysql pod



$ kubectl create -f wordpress-deployment.yml

Check if pods are runing or not



$ kubectl get pod -n mysql-example

NAME                     READY   STATUS    RESTARTS   AGE
mysql-58c8f46579-whxz6   1/1     Running   0          31s



$ kubectl get pod -n wordpress-example

NAME                         READY   STATUS              RESTARTS   AGE
wordpress-856b4c866f-4xfpz   1/1     ContainerCreating   0          20s

To reach the Wordpress website you need to expose the Wordpress service. In this instance a ClusterIP isn’t sufficient because you need to be able to contact it from the exterior of the cluster.
To Expose Wordpress service



$ kubectl create -f wordpress-nodeport.yml
$ kubectl get svc -n wordpress-example

NAME        TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
wordpress   NodePort   10.98.102.140   <none>        80:31343/TCP   30s

You can now see that Wordpress service is exposed on port 31499/TCP on workers. To configure our website let’s open browser and enter url
http://worker-IP:31343

Now you can finish the installation of your Wordpress application using the following details :

Database name : wordpress

User name : root

Password : redhat

Database host : mysql.mysql-example.svc.cluster.local

I hope that you have understood the significant role of Kube-DNS and Kubernetes Services.

Kubernetes Storage Using Ceph

Ajinkya Ingole — Wed, 18 Mar 2020 09:34:00 +0000

What is Kubernetes?

Kubernetes, the awesome container orchestration tool is changing the way applications are being developed and deployed. You can specify the required resources you want and have it available without worrying about the underlying infrastructure. Kubernetes is way ahead in terms of high availability, scaling, managing your application, but storage section in the k8s is still evolving. Many storage supports are getting added and are production-ready.

People are preferring clustered applications to store the data. But, what about the non-clustered applications? Where do these applications store data to make it highly available? Considering these questions, let’s go through the Ceph storage and its integration with Kubernetes.

What is Ceph Storage?

Ceph is open source, software-defined storage maintained by RedHat. It’s capable of block, object, and file storage. The clusters of Ceph are designed in order to run on any hardware with the help of an algorithm called CRUSH (Controlled Replication Under Scalable Hashing). This algorithm ensures that all the data is properly distributed across the cluster and data quickly without any constraints. Replication, Thin provisioning, Snapshots are the key features of the Ceph storage.

There are good storage solutions like Gluster, Swift but we are going with Ceph for following reasons:
1. File, Block, and Object storage in the same wrapper.
2. Better transfer speed and lower latency.
3. Easily accessible storage that can quickly scale up or down.

We are going to use Ceph-RBD storage in this blog to integrate with Kubernetes.

Ceph Deployment

Deploying highly available Ceph cluster is pretty straightforward and easy. I am assuming that you are familiar with setting up the Ceph cluster.

If you check the status, you should see something like:

Here notice that my Ceph monitors hostnames are ip-10-0-0-58, ip-10-0-0-78 and ip-10-0-0-237

There are few things you need to do once your ceph cluster is up and running.

create a pool



ceph osd pool create kubernetes 1024

List pools



ceph osd lspools

Create an RBD_image inside kubernetes pool



rbd create kube --size 64 -p kubernetes

View created RBD_image



rbd info kube -p kubernetes

Remove image permissions



rbd feature disable kube -p kubernetes object-map fast-diff deep-flatten

View created RBD_image and chech if permissions are removed or not



rbd info kube -p kubernetes

K8s Integration

After setting up the Ceph cluster, we would consume it with Kubernetes. I am assuming that your Kubernetes cluster is up and running. We will be using Ceph-RBD as a storage in Kubernetes.

Ceph-RBD and Kubernetes

We need a Ceph RBD client to achieve interaction between Kubernetes cluster and CephFS.
Check the repo https://github.com/ajinkyaingole30/K8s-Ceph.git

Setting up kubernetes master as ceph client so that we can use rbd_image as storage in Kubernetes

Copy ceph.repo in /etc/yum.repos.d/ and download ceph-common



cp ceph.repo /etc/yum.repos.d/ceph.repo
yum install ceph-common

start and enable rbdmap service



systemctl start rbdmap
systemctl enable rbdmap

Copy ceph.client,admin.keyring & also ceph.conf from ceph node and paste it in /etc/ceph of kubernetes-master (ceph client).
you can direct scp it from ceph node to kubernetes master



scp /etc/ceph/ceph.client.admin.keyring root@master-node:/etc/ceph/
scp /etc/ceph/ceph.conf root@master-node:/etc/ceph/

Check if you can see the pools from kubernetes master (ceph client)



rados lspools

Now map the rbd_image to your ceph client



rbd map kube -p kubernetes

check mapped rbd_image



rbd showmapped

lsblk

This client is not in the official kube-controller-manager container so let’s try to create the external storage plugin for Ceph.

download https://github.com/ajinkyaingole30/K8s-Ceph.git



git clone https://github.com/ajinkyaingole30/K8s-Ceph.git

Generate a csi-config-map.yaml file similar to the example below, substituting the fsid for “clusterID”, and the monitor addresses for “monitors”:



---
apiVersion: v1
kind: ConfigMap
data:
  config.json: |-
    [
      {
        "clusterID": "671be3f7-44b4-a79d-07cf4ae58ee1",
        "monitors": [
          "10.0.0.58:6789",
          "10.0.0.78:6789",
          "10.0.0.237:6789"
        ]
      }
    ]
metadata:
  name: ceph-csi-config

Once generated, store the new ConfigMap object in Kubernetes:



kubectl apply -f csi-config-map.yaml

Also generate a ksm-config.yaml



---
apiVersion: v1
kind: ConfigMap
data:
  config.json: |-
    {
      "vault-test": {
        "encryptionKMSType": "vault",
        "vaultAddress": "http://vault.default.svc.cluster.local:8200",
        "vaultAuthPath": "/v1/auth/kubernetes/login",
        "vaultRole": "csi-kubernetes",
        "vaultPassphraseRoot": "/v1/secret",
        "vaultPassphrasePath": "ceph-csi/",
        "vaultCAVerify": "false"
      }
    }
metadata:
  name: ceph-csi-encryption-kms-config


kubectl apply -f kms-config.yaml

ceph-csi requires the cephx credentials for communicating with the Ceph cluster. Generate a csi-rbd-secret.yaml file similar to the example below, using the newly created Kubernetes user id and cephx key:



---
apiVersion: v1
kind: Secret
metadata:
  name: csi-rbd-secret
  namespace: default
stringData:
  userID: admin
  userKey: AQD9o0Fd6hQRChAAt7fMaSZXduT3NWEqylNpmg==

Once generated, store the new Secret object in Kubernetes:



kubectl apply -f csi-rbd-secret.yaml

Configure ceph-csi plugins

Create the required ServiceAccount and RBAC ClusterRole/ClusterRoleBinding Kubernetes objects. These objects do not necessarily need to be customized for your Kubernetes environment and therefore can be used as-is from the ceph-csi deployment YAMLs:



kubectl apply -f csi-provisioner-rbac.yaml
kubectl apply -f csi-nodeplugin-rbac.yaml

Finally, create the ceph-csi provisioner and node plugins. With the possible exception of the ceph-csi container release version, these objects do not necessarily need to be customized for your Kubernetes environment and therefore can be used as-is from the ceph-csi deployment YAMLs:



kubectl apply -f csi-rbdplugin-provisioner.yaml
kubectl apply -f csi-rbdplugin.yaml

Using Ceph Block Devices create a storageclass

The Kubernetes StorageClass defines a class of storage. Multiple StorageClass objects can be created to map to different quality-of-service levels (i.e. NVMe vs HDD-based pools) and features.

For example, to create a ceph-csi StorageClass that maps to the kubernetes pool created above, the following YAML file can be used after ensuring that the “clusterID” property matches your Ceph cluster’s fsid:



---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
   name: csi-rbd-sc
provisioner: rbd.csi.ceph.com
parameters:
   clusterID: 671be3f7-44b4-a79d-07cf4ae58ee1
   pool: kubernetes
   csi.storage.k8s.io/provisioner-secret-name: csi-rbd-secret
   csi.storage.k8s.io/provisioner-secret-namespace: default
   csi.storage.k8s.io/node-stage-secret-name: csi-rbd-secret
   csi.storage.k8s.io/node-stage-secret-namespace: default
reclaimPolicy: Delete
mountOptions:
   - discard

kubectl apply -f csi-rbd-sc.yaml

Create a Persistent Volume Claim

A PersistentVolumeClaim is a request for abstract storage resources by a user. The PersistentVolumeClaim would then be associated to a Pod resource to provision a PersistentVolume, which would be backed by a Ceph block image. An optional volumeMode can be included to select between a mounted file system (default) or raw block device-based volume.

To create a block-based PersistentVolumeClaim that utilizes the ceph-csi-based StorageClass created above, the following YAML can be used to request raw block storage from the csi-rbd-sc StorageClass:



---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: raw-block-pvc
spec:
  accessModes:
    - ReadWriteOnce
  volumeMode: Block
  resources:
    requests:
      storage: 50Mi
  storageClassName: csi-rbd-sc

kubectl apply -f raw-block-pvc.yaml

Check the pod if it is running or not



kubectl get pods

Check if the pvc is bound



kubectl get pvc

Check if the pv is bound



kubectl get pv

To create a file-system-based PersistentVolumeClaim that utilizes the ceph-csi-based StorageClass created above, the following YAML can be used to request a mounted file system (backed by an RBD image) from the csi-rbd-sc StorageClass:



---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: rbd-pvc
spec:
  accessModes:
    - ReadWriteOnce
  volumeMode: Filesystem
  resources:
    requests:
      storage: 50Mi
  storageClassName: csi-rbd-sc


kubectl apply -f fs_pvc.yaml

Check if the pvc rbd-pvc is bound or not



kubectl get pvc

List Rbd images in kubernetes pools and again remove the permission of the new created rbd



# rbd ls -p kubernetes
# rbd feature disable csi-vol-db6a4c87-c4c8-11ea-87a0-721582595d51 -p kubernetes object-map fast-diff deep-flatten

here "csi-vol-db6a4c87-c4c8-11ea-87a0-721582595d51" is the name of my new rdb image created after creating pvc.

The following demonstrates and example of binding the above PersistentVolumeClaim to a Pod resource as a mounted file system:



---
apiVersion: v1
kind: Pod
metadata:
  name: ceph-pod
spec:
  containers:
    - name: web-server
      image: nginx
      volumeMounts:
        - name: mypvc
          mountPath: /var/lib/www/html
  volumes:
    - name: mypvc
      persistentVolumeClaim:
        claimName: rbd-pvc
        readOnly: false

kubectl apply -f pod.yaml

Check the pod if it is running or not



kubectl get pods

Get into the pod to check if the volume is attached



kubectl exec -it ceph-pod -- df -hT | grep /dev/rbd0

Using this you can integrate ceph with kubernetes

I hope you enjoyed the article and found the information useful. Please share your feedback.

Happy Cephing!

Ceph Cluster monitoring using Prometheus and Grafana

Ajinkya Ingole — Thu, 05 Mar 2020 18:38:02 +0000

What is Ceph?

Ceph object storage is accessible through Amazon Simple Storage Service (S3) and OpenStack Swift Representational State Transfer (REST)-based application programming interfaces (APIs), and a native API for integration with software applications.

Ceph block storage makes use of a Ceph Block Device, which is a virtual disk that can be attached to bare-metal Linux-based servers or virtual machines. The Ceph Reliable Autonomic Distributed Object Store (RADOS) provides block storage capabilities, such as snapshots and replication. The Ceph RADOS Block Device is integrated to work as a back end with OpenStack Block Storage.

What is Prometheus?

Prometheus is a free software application used for event monitoring and alerting.It records real-time metrics in a time series database (allowing for high dimensionality) built using a HTTP pull model, with flexible queries and real-time alerting.The project is written in Go and licensed under the Apache 2 License, with source code available on GitHub, and is a graduated project of the Cloud Native Computing Foundation, along with Kubernetes and Envoy.

Prometheus collects metrics from monitored targets by scraping metrics HTTP endpoints on these targets. Since Prometheus also exposes data in the same manner about itself, it can also scrape and monitor its own health.

What is Grafana?

Grafana is an open source solution for running data analytics, pulling up metrics that make sense of the massive amount of data & to monitor our apps with the help of cool customizable dashboards.

Grafana connects with every possible data source, commonly referred to as databases such as Graphite, Prometheus, Influx DB, ElasticSearch, MySQL, PostgreSQL etc.

Grafana being an open source solution also enables us to write plugins from scratch for integration with several different data sources.

The tool helps us study, analyse & monitor data over a period of time, technically called time series analytics.

Ceph Deployment

Deploying highly available Ceph cluster is pretty straightforward and easy. I am assuming that you are familiar with setting up the Ceph cluster. If not then refer the official document or following commands.

Configure Ceph repo:

sudo vim /etc/yum.repos.d/ceph.repo

[ceph]
name=Ceph packages for $basearch
baseurl=https://download.ceph.com/rpm-nautilus/el7/$basearch
enabled=1
priority=1
gpgcheck=1
gpgkey=https://download.ceph.com/keys/release.asc

[ceph-noarch]
name=Ceph noarch packages
baseurl=https://download.ceph.com/rpm-nautilus/el7/noarch
enabled=1
priority=1
gpgcheck=1
gpgkey=https://download.ceph.com/keys/release.asc

[ceph-source]
name=Ceph source packages
baseurl=https://download.ceph.com/rpm-nautilus/el7/SRPMS
enabled=0
priority=1
gpgcheck=1
gpgkey=https://download.ceph.com/keys/release.asc

Installing ceph-deploy

sudo yum install ceph-deploy -y

Create a directory

 mkdir ceph-cluster

 cd ceph-cluster

Create the cluster:

 ceph-deploy new node1 node2 node3

Install Ceph packages:

 ceph-deploy install node1 node2 node3

Deploy the initial monitors and gather the keys

 ceph-deploy mon create-initial

Create admin

ceph-deploy admin node1 node2 node3

Create Mgr

ceph-deploy mgr create node1

Create Osds

ceph-deploy osd create --data /dev/xvdb node1
ceph-deploy osd create --data /dev/xvdb node2
ceph-deploy osd create --data /dev/xvdb node3

Check your cluster's status

sudo ceph -s

you should see something like:

Installing Prometheus

Run the following command to download and install Prometheus.

sudo wget https://github.com/prometheus/prometheus/releases/download/v2.8.1/prometheus-2.8.1.linux-amd64.tar.gz

Add a Prometheus user.

sudo useradd --no-create-home --shell /bin/false prometheus

Create needed directories.

sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus

Change the owner of the above directories.

sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Now go to Prometheus downloaded location and extract it.

sudo tar -xvzf prometheus-2.8.1.linux-amd64.tar.gz

Rename it as per your preference.

sudo mv prometheus-2.8.1.linux-amd64 prometheuspackage

Copy “prometheus” and “promtool” binary from the “prometheuspackage” folder to “/usr/local/bin”.

sudo cp prometheuspackage/prometheus /usr/local/bin/
sudo cp prometheuspackage/promtool /usr/local/bin/

Change the ownership to Prometheus user.

sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

Copy “consoles” and “console_libraries” directories from the “prometheuspackage” to “/etc/prometheus folder”

sudo cp -r prometheuspackage/consoles /etc/prometheus
sudo cp -r prometheuspackage/console_libraries /etc/prometheus

Change the ownership to Prometheus user

sudo chown -R prometheus:prometheus /etc/prometheus/consoles
sudo chown -R prometheus:prometheus /etc/prometheus/console_libraries

Now we will create the prometheus.yml file.

sudo vim /etc/prometheus/prometheus.yml

Add the following configuration to the file.

global:
  scrape_interval: 10s

scrape_configs:
  - job_name: 'prometheus_master'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:9283']

---{copy the port no. which you get after firing command ceph mgr services}---

Change the ownership of the file.

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml

Configure the Prometheus Service File.

sudo vim /etc/systemd/system/prometheus.service

Copy the following content to the file.

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
--config.file /etc/prometheus/prometheus.yml \
--storage.tsdb.path /var/lib/prometheus/ \
--web.console.templates=/etc/prometheus/consoles \
--web.console.libraries=/etc/prometheus/console_libraries

[Install]
WantedBy=multi-user.target

Reload the systemd service.

sudo systemctl daemon-reload

Start the Prometheus service.

sudo systemctl start prometheus

Check service status.

systemctl status prometheus

Use the following Url to access UI.

http://Server-IP:9090/graph

Then you can see the following interface.

Installing grafana

Create a repo file.

vim /etc/yum.repos.d/grafana.repo

Add the following contents to file:

[grafana]
name=grafana
baseurl=https://packages.grafana.com/oss/rpm
repo_gpgcheck=1
enabled=1
gpgcheck=1
gpgkey=https://packages.grafana.com/gpg.key
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
sudo vim /etc/yum.repos.d/grafana.repo

Enter the following command:

sudo yum install grafana -y

Continue with following commands to install the free type and urw fonts.

sudo yum install fontconfig
sudo yum install freetype*
sudo yum install urw-fonts

Check the status of the service.

sudo systemctl status grafana-server

If service is not active, start it using the following command:

sudo systemctl start grafana-server

Enable Grafana service on system boot

sudo systemctl enable grafana-server.service

Use the following URL to access the Grafana web interface.

http://Your Server IP or Host Name:3000/

Then you can see the following interface.

Enabeling dashboard service on ceph cluster

Mgr enable dashboard

ceph mgr module enable dashboard --force

Mgr enable Prometheus

 ceph mgr module enable prometheus --force

Edit the ceph.conf

 vim ceph-deploy/ceph.conf

Add:

[mon]
        mgr initial modules = dashboard

Check Mgr Services:

---{update the file /etc/prometheus/prometheus.yml with the obtained port no. as target port no. }---

As you have successfully installed prometheus and grafana for ceph monitoring

Let us begin the grafana setup now
1. Login to grafana with default username and password as admin
2. Click on to create a datasource
3. Select Prometheus

4. Enter url of prometheus

5. Click on Import and enter ceph-cluster grafana dashboard id "7056"
6. Choose Name and Ceph Prometheus data source

Finally we have successfully integrated our Ceph Cluster with Prometheus and Grafana!

DEV Community: Ajinkya Ingole

Deploying docker-based CEPH cluster using ceph-ansible

Why Docker and Ceph?

Install ansible

How to connect to your Kubernetes services using internal DNS

Introduction

What things get DNS names?

Now you can finish the installation of your Wordpress application using the following details :

Kubernetes Storage Using Ceph

What is Kubernetes?

What is Ceph Storage?

Ceph Deployment

K8s Integration

Ceph-RBD and Kubernetes

Ceph Cluster monitoring using Prometheus and Grafana

What is Ceph?

What is Prometheus?

What is Grafana?

Ceph Deployment

Installing Prometheus

Installing grafana

Enabeling dashboard service on ceph cluster

As you have successfully installed prometheus and grafana for ceph monitoring

Using this you can monitor your ceph cluster!