Know Everything About Prometheus Operator in Kubernetes

⇩ Download!

Priyansh Khodiyar

Author

Share with friends

Imagine this: You're managing a bustling Kubernetes environment with numerous applications and services running in your cluster.

As your system scales and evolves, efficiently monitoring and managing the health and performance of your applications becomes a critical challenge. This is where Prometheus Operator comes to the rescue.

In this blog, we'll explore the essential steps to install and leverage Prometheus Operator in Kubernetes, providing you with the tools and knowledge to streamline your monitoring workflows.

We'll guide you through the installation process and show you how to harness its power to gain valuable insights into your cluster's health.

Let's overcome the challenges of Kubernetes monitoring together with the Prometheus Operator.

What are Operators in Kubernetes?

Operators are custom controllers built on the Kubernetes API that extend its functionality.

They sum up domain-specific knowledge and automation logic to handle the lifecycle management of applications and their associated resources.

Operators leverage Custom Resource Definitions (CRDs) to define custom resources that represent the desired state of the application.

By observing these custom resources, operators continuously reconcile the current state with the desired state, ensuring the application remains desired.

This dynamic nature enables operators to automate tasks like provisioning, scaling, upgrading, and even performing complex operational tasks specific to the application.

Operators bring declarative management and automation to Kubernetes, allowing you to define and enforce application-specific behavior.

They provide a higher level of abstraction, combining the operational complexities and enabling you to focus on the core requirements of your application.

What is Prometheus Operator?

Prometheus Operator can be described as a robust toolkit designed to streamline the deployment, configuration, and management of Prometheus instances within a Kubernetes cluster.

It is a vital monitoring companion, automating various tasks that would otherwise require manual effort.

By leveraging the declarative nature of Kubernetes, Prometheus Operator enables users to define their desired Prometheus state using custom resources.

This helps streamline the provisioning of new instances, configuration management, and ensuring high availability.

Also Read: Know the Differences between Grafana vs New Relic

Key Features of Prometheus Operator

Prometheus Operator is a game-changer that brings many powerful features to the table.

Buckle up as we explore the key features that make Prometheus Operator a must-have in your Kubernetes monitoring arsenal.

Simplified Deployment and Configuration

With Prometheus Operator, gone are the days of manually configuring Prometheus instances. It automates the entire process, making deployment a breeze.

Simply define your desired configuration using custom resources, and let Prometheus Operator handle the rest.

Say goodbye to tedious setup and hello to streamlined monitoring workflows.

Dynamic Scaling and Auto-Discovery

As your Kubernetes cluster evolves, Prometheus Operator effortlessly scales with it.

It dynamically adjusts to changes, automatically discovering new services and adjusting configurations.

This means you can focus on adding and scaling applications without worrying about the intricacies of monitoring setup.

Self-Healing and High Availability

Prometheus Operator takes care of the resilience of your monitoring infrastructure.

It ensures that Prometheus instances are always up and running, recovering from failures, and handling restarts seamlessly.

With built-in high-availability features, you can rely on Prometheus Operator to keep your monitoring system resilient and available.

Integration with Alerting and Visualization

Prometheus Operator goes beyond monitoring alone. It seamlessly integrates with Alertmanager and Grafana, enabling you to create custom alerts and visualizations effortlessly.

This integration empowers you to build comprehensive monitoring and alerting workflows, ensuring timely notifications and insightful visualizations for actionable insights.

Customization and Extensibility

Prometheus Operator offers flexibility and extensibility, allowing you to tailor it to your specific monitoring requirements.

Customize the configuration to suit your needs, define monitoring rules, and extend functionality with additional exporters or custom integrations.

Prometheus Operator allows you to mold it to your unique monitoring landscape.

Also Read: Which One to Choose between Grafana and Datadog?

Prometheus Operator - Custom Resource Definitions (CRDs)

Let's look at some of the top CRDs of Prometheus Operator.

BlackBox Exporter

Blackbox Exporter is an agent that allows you to probe and monitor various endpoints from an external perspective.

It simulates interactions with endpoints such as HTTP, TCP, ICMP, DNS, and more, providing valuable insights into their availability, responsiveness, and overall health.

By regularly probing these endpoints, Blackbox Exporter shines a light on potential issues that may go unnoticed within your Kubernetes cluster.

It uncovers performance bottlenecks, latency problems, or service failures that could impact your application's performance or user experience.

Prometheus

Prometheus is a time-series database specifically designed for monitoring purposes.

It collects, stores, and analyzes metrics, allowing you to track the performance, health, and availability of your applications, services, and infrastructure components.

Prometheus follows a pull-based model, meaning it actively scrapes metrics from the targets you configure, such as Kubernetes containers, pods, or even external systems.

It supports a flexible query language, PromQL. That further enables you to explore and extract meaningful insights from your collected metrics.

Also Read: Differences between Monitoring and Observability

Alertmanager

Alertmanager acts as a centralized hub for handling and routing alerts generated by Prometheus.

It receives alerts from Prometheus based on predefined rules and configurations and performs various actions, such as grouping, deduplication, and routing. It is to ensure that alerts reach the appropriate recipients.

One of the primary functions of Alertmanager is alert grouping. It intelligently groups similar alerts, avoiding alert fatigue and reducing noise.

By consolidating related alerts, Alertmanager provides a more concise and manageable view of the system's health. That makes it easier for operators to identify and address issues effectively.

ThanosRuler

ThanosRuler extends the capabilities of Prometheus by enabling distributed querying and long-term storage. It works with Prometheus and other components to provide a scalable, fault-tolerant monitoring solution.

One of the primary functions of ThanosRuler is distributed querying. It allows you to query data across multiple Prometheus instances, enabling efficient analysis and aggregation of metrics from different sources.

This distributed querying capability enhances scalability, enabling you to handle large amounts of data and efficiently retrieve insights from a distributed monitoring setup.

ServiceMonitor

ServiceMonitor provides a declarative approach to define and manage the monitoring configuration for Kubernetes services.

In a YAML configuration file, it lets you specify the target services you want to monitor, along with the desired metrics and scraping endpoints.

ServiceMonitor leverages Kubernetes's Custom Resource Definition (CRD) capability, which extends the Kubernetes API and allows you to define your resource types.

By defining ServiceMonitor resources, you can specify the monitoring requirements for your services, such as the service name, label selectors, and the desired Prometheus instance to scrape metrics.

Also Read: Know the Differences between New Relic vs Datadog

PodMonitor

PodMonitor enables you to specify monitoring configurations for specific pods within your Kubernetes cluster.

Using a declarative YAML configuration file, allows you to define the pods you want to monitor, along with the desired metrics and scraping endpoints.

With PodMonitor, you can easily target specific pods for monitoring based on label selectors.

This provides fine-grained control over the monitoring process, allowing you to focus on critical pods or specific application components that require dedicated monitoring.

Probe

At its core, a probe is a diagnostic mechanism that periodically checks the health and readiness of a pod. Kubernetes provides two types of probes: liveness probes and readiness probes.

A liveness probe determines whether a pod is running as expected. It periodically sends a request to a specified endpoint within the pod and checks for a successful response.

If the probe fails, Kubernetes considers the pod unhealthy and may automatically restart it.

On the other hand, a readiness probe determines whether a pod is ready to receive network traffic. It verifies if the pod is prepared to serve requests and properly handle incoming traffic.

If the readiness probe fails, Kubernetes will temporarily remove the pod from the pool of endpoints to prevent it from receiving traffic until it becomes ready again.

PrometheusRule

PrometheusRule enables you to define rules that specify how Prometheus should evaluate and generate alerts based on your metrics data.

These rules define conditions and thresholds that trigger alerts when certain criteria are met. PrometheusRule also allows you to define recording rules, which help pre-calculate and store derived metrics for efficient querying.

PrometheusRule uses a declarative YAML configuration file to define the rules. This configuration file specifies the metrics to evaluate, the conditions to trigger alerts, and the actions to take when an alert is fired.

You can define rules based on specific metrics, labels, aggregation functions, and time-based conditions.

AlertmanagerConfig

AlertmanagerConfig provides a configuration file that allows you to define the routing and notification behavior of Alertmanager.

This configuration file specifies how alerts should be grouped, filtered, and forwarded to different receivers for notification.

With AlertmanagerConfig, you can define routing rules based on various criteria, such as severity, alert labels, or specific alert annotations.

These rules determine which alerts should be sent to different notification channels or recipients.

How to Install & Deploy Prometheus Operator?

Prometheus Operator is an open-source project that simplifies the deployment and management of Prometheus and related monitoring components in Kubernetes.

It provides a Kubernetes-native way to configure, manage, and monitor Prometheus instances and other components like Alertmanager and Grafana and many more features so that you can sit back and not have to deal with all the complexities that come with Kubernetes.

There are multiple ways to install and deploy the Prometheus Operator, depending on your requirements and preferences.

Here are some of the methods of installing & deploying Prometheus Operator.

Manual Installation

This method involves manually deploying the Prometheus Operator by creating and applying Kubernetes manifests.

You can download the required YAML files from the Prometheus Operator repository and customize them as per your needs.

Then, you can use kubectl to apply the manifests to your Kubernetes cluster.

Helm Chart

Helm is a package manager for Kubernetes that simplifies the deployment and management of applications.

The Prometheus Operator provides an official Helm chart that allows you to install and configure the operator and its components using Helm commands.

Helm handles the installation and configuration of all required resources, making it easier to manage the Prometheus Operator.

Also Read: Differences between Splunk and ELK

kube-prometheus

kube-prometheus is a Kubernetes-native solution that provides a set of manifests and tools for deploying a full monitoring stack, including the Prometheus Operator, Prometheus, Grafana, Alertmanager, and more.

It offers a complete end-to-end monitoring solution with pre-configured dashboards and alerting rules. You can clone the kube-prometheus repository and deploy the entire stack using provided manifests and Helm charts.

Kubernetes Operators

Kubernetes Operators are Kubernetes-native applications that extend the functionality of the cluster by automating the management of complex, stateful applications.

The Prometheus Operator is itself a Kubernetes Operator, so you can use Operator-specific tools and frameworks like Operator Lifecycle Manager (OLM) or OperatorHub to install and manage the Prometheus Operator as a custom resource in your cluster.

Kubernetes Package Managers

There are other Kubernetes package managers like Kustomize, Kubeapps, and Ksonnet that can be used to install and deploy the Prometheus Operator.

Each method has its own advantages and considerations, so choose the one that best fits your requirements, familiarity with the tools, and infrastructure setup.

In this tutorial, we'll focus mainly on these 3 installation methods:

1. Deploy Prometheus Operator Manually
2. Deploy Prometheus Operator Using Helm
3. Deploy Prometheus Operator Using kube-prometheus

Also Read: Monitoring Tools & Best Practices for Microservices

Deploy Prometheus Operator Manually

Prerequisites

Ensure you have the following prerequisites before starting the deployment process:

• A Kubernetes cluster up and running.

• kubectl command-line tool installed and configured to access your cluster.

• helm package manager for Kubernetes installed.

Step 1: Clone the Prometheus Operator repository

Clone the Prometheus Operator repository from GitHub by running the following command:

git clone https://github.com/prometheus-operator/prometheus-operator.git

Step 2: Change directory

Use this command witch to the Prometheus Operator directory.

cd prometheus-operator

Step 3: Create a namespace

Create a new namespace where the Prometheus Operator will be deployed using this command.

kubectl create namespace prometheus-operator

Step 4: Deploy the Prometheus Operator

Deploy the Prometheus Operator using the Helm package manager. Run the following command:

helm install prometheus-operator stable/prometheus-operator --namespace prometheus-operator

Step 5: Verify the deployment

Use this command to check the status of the deployment to ensure it was successful.

kubectl get pods -n prometheus-operator

Make sure all the required pods are in the "Running" state before proceeding.

Step 6: Access the Prometheus Operator

By default, the Prometheus Operator deploys Prometheus and Grafana. Retrieve the Prometheus server URL by running the following command:

kubectl --namespace prometheus-operator get svc prometheus-operator-prometheus -o jsonpath="{.status.loadBalancer.ingress[0].hostname}"

This command retrieves the external hostname of the Prometheus server service. Note down the value for future reference.

Step 7: Access the Grafana dashboard

Retrieve the Grafana URL by running the following command:

kubectl --namespace prometheus-operator get svc prometheus-operator-grafana -o jsonpath="{.status.loadBalancer.ingress[0].hostname}"

Step 8: Configure Prometheus rules

If you have custom Prometheus rules, you can configure them by creating a ConfigMap in the prometheus-operator namespace.

Here's an example of creating a ConfigMap from a file:

kubectl create configmap prometheus-rules --from-file=path/to/prometheus.rules.yml -n prometheus-operator

Adjust the path to your Prometheus rules file accordingly.

Step 9: Configure Prometheus ServiceMonitor

To monitor your own applications, you can create a ServiceMonitor resource. Create a ServiceMonitor YAML file (e.g., my-service-monitor.yaml) and apply it to the prometheus-operator namespace:

kubectl apply -f my-service-monitor.yaml -n prometheus-operator

Make sure the ServiceMonitor specifies the correct labels and selectors to match your application.

Step 10: Access Prometheus and Grafana

You can now access Prometheus and Grafana using the URLs obtained in steps 6 and 7. Open a web browser and navigate to the respective URLs.

• Prometheus: Enter the Prometheus server URL from step 6 in the browser. This allows you to view and query metrics.

• Grafana: Enter the Grafana URL from step 7 in the browser. Login with the default credentials (admin/admin) and configure your dashboards to visualize your metrics.

You have successfully deployed the Prometheus Operator manually and can now start monitoring your applications using Prometheus and Grafana.

Now let's explore how we can deploy using Helm.

Also Read: How to Create & Manage Kubernetes Secrets?

Deploy Prometheus Operator using Helm

Prerequisites

Ensure you have the following prerequisites before starting the deployment process:

• A Kubernetes cluster up and running.

• kubectl command-line tool installed and configured to access your cluster.

• helm package manager for Kubernetes installed.

Step 1: Add the Prometheus Operator Helm chart repository

Add the official Prometheus Operator Helm chart repository by running the following command:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts

Step 2: Update Helm repositories

Update your local Helm repositories to fetch the latest charts:

helm repo update

Step 3: Create a namespace

Create a new namespace where the Prometheus Operator will be deployed:

kubectl create namespace prometheus-operator

Step 4: Deploy the Prometheus Operator

Deploy the Prometheus Operator using Helm. Run the following command:

helm install prometheus-operator prometheus-community/kube-prometheus-stack --namespace prometheus-operator

This command deploys the Prometheus Operator along with the entire monitoring stack, including Prometheus, Grafana, and Alertmanager.

Step 5: Verify the deployment

Check the status of the deployment to ensure it was successful:

kubectl get pods -n prometheus-operator

Make sure all the required pods are in the "Running" state before proceeding.

Step 6: Access the Prometheus Operator

By default, the Prometheus Operator deploys Prometheus and Grafana. Retrieve the Prometheus server URL by running the following command:

kubectl --namespace prometheus-operator get svc prometheus-operator-kube-prometheus-prometheus -o jsonpath="{.status.loadBalancer.ingress[0].hostname}"

This command retrieves the external hostname of the Prometheus server service. Note down the value for future reference.

Step 7: Access the Grafana dashboard

Retrieve the Grafana URL by running the following command:

kubectl --namespace prometheus-operator get svc prometheus-operator-grafana -o jsonpath="{.status.loadBalancer.ingress[0].hostname}"

Step 8: Configure Prometheus rules

If you have custom Prometheus rules, you can configure them by creating a ConfigMap in the prometheus-operator namespace.

Here's an example of creating a ConfigMap from a file:

kubectl create configmap prometheus-rules --from-file=path/to/prometheus.rules.yml -n prometheus-operator

Adjust the path to your Prometheus rules file accordingly.

Step 9: Configure Prometheus ServiceMonitor

To monitor your own applications, you can create a ServiceMonitor resource. Create a ServiceMonitor YAML file (e.g., my-service-monitor.yaml) and apply it to the prometheus-operator namespace:

kubectl apply -f my-service-monitor.yaml -n prometheus-operator

Make sure the ServiceMonitor specifies the correct labels and selectors to match your application.

Step 10. Access Prometheus and Grafana

You can now access Prometheus and Grafana using the URLs obtained in steps 6 and 7. Open a web browser and navigate to the respective URLs.

• Prometheus: Enter the Prometheus server URL from step 6 in the browser. This allows you to view and query metrics.

• Grafana: Enter the Grafana URL from step 7 in the browser. Login with the default credentials (admin/admin) and configure your dashboards to visualize your metrics.

And you're done!

Now let us see how to deploy using kube-prometheus.

Also Read: Kubernetes vs HashiCorp Nomad

Prometheus Operator with remote_write

To configure remote_write with the Prometheus Operator, follow these steps:

Step 1: Install the Prometheus Operator

Install the Prometheus Operator by using your preferred methods, such as Helm, kube-prometheus, or manual installation.

Refer to the Prometheus Operator documentation for detailed installation instructions.

Step 2: Create a ConfigMap

Create a ConfigMap that contains the Prometheus configuration. You can use the following example as a template:

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: <namespace>
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
    remote_write:
      - url: "<remote_write_endpoint>"

Replace <namespace> with the namespace where you want to deploy the ConfigMap, and <remote_write_endpoint> with the URL of your remote write endpoint.

Step 3: Apply the ConfigMap

Apply the ConfigMap to your cluster using the following command:

kubectl apply -f prometheus-config.yaml

Step 4: Create a Prometheus resource

Create a Prometheus resource that references the ConfigMap you created in the previous step. Use the following example as a template:

apiVersion: monitoring.coreos.com/v1
kind: Prometheus
metadata:
  name: prometheus
  namespace: <namespace>
spec:
  serviceAccountName: prometheus
  serviceMonitorSelector:
    matchLabels:
      release: <release-name>
  resources:
    requests:
      memory: 400Mi
  configMaps:
    - name: prometheus-config
      namespace: <namespace>

Replace <namespace> with the namespace where you deployed the ConfigMap, and <release-name> with the release name of the Prometheus Operator.

Step 5: Apply the Prometheus resource

Apply the Prometheus resource to your cluster using the following command:

kubectl apply -f prometheus-resource.yaml

Step 6: Verify remote_write configuration

Verify that remote_write is configured correctly in Prometheus by accessing the Prometheus UI. Retrieve the Prometheus URL by running the following command:

kubectl --namespace <namespace> get svc <release-name>-prometheus

Access the Prometheus UI in your web browser using the URL obtained, and navigate to the "Status" > "Configuration" page. Verify that the remote_write URL is correctly set.

That's it! You have configured remote_write with the Prometheus Operator.

Prometheus will now send its metrics data to the specified remote write endpoint. Ensure that your remote write endpoint is properly configured to receive and store the metrics data sent by Prometheus.

Also Read: Kubernetes Security, Namespace, Resource Limits Best Practices

Prometheus Operator - scrape_config vs ServiceMonitor

Both scrape_config and ServiceMonitor are used in Prometheus for defining the targets to be scraped for metrics. However, they serve different purposes:

scrape_config

The scrape_config is a configuration block defined in the Prometheus configuration file (prometheus.yml). It specifies the targets to be scraped by Prometheus for metrics collection.

It can include static configurations for individual endpoints or job-based configurations using relabeling.

The scrape_config is typically used when manually configuring Prometheus without using the Prometheus Operator. It requires manual modification of the Prometheus configuration file.

ServiceMonitor

ServiceMonitor is a custom resource definition (CRD) provided by the Prometheus Operator. It allows declarative configuration of monitoring targets within a Kubernetes cluster.

ServiceMonitor resources are managed by the Prometheus Operator, which automatically discovers and configures Prometheus to scrape the specified targets. ServiceMonitors leverage Kubernetes labels and selectors to dynamically discover and monitor services in a namespace.

Here are some key differences between scrape_config and ServiceMonitor:

• Configuration Format: scrape_config is part of the Prometheus configuration file (YAML), while ServiceMonitor is a Kubernetes resource (YAML or JSON).

• Dynamic Discovery: ServiceMonitor provides dynamic discovery of targets based on labels and selectors, whereas scrape_config requires manually specifying each target.

• Management: scrape_config requires manual modification of the Prometheus configuration file, while ServiceMonitor resources are managed by the Prometheus Operator.

• Integration with Kubernetes: ServiceMonitor integrates tightly with Kubernetes by leveraging labels and selectors, making it easier to manage and monitor applications in a dynamic Kubernetes environment.

• Operator Compatibility: scrape_config can be used with both Prometheus and the Prometheus Operator, whereas ServiceMonitor is specifically designed for use with the Prometheus Operator.

Troubleshooting: Why is Prometheus Operator Not Picking up ServiceMonitor?

When the Prometheus Operator is not picking up a ServiceMonitor, there could be various reasons for the issue. Here are some possible examples and troubleshooting steps to resolve them:

Reason #1: Namespace Mismatch

Here's how to troubleshoot if this is the reason the Prometheus Operator not picking up ServiceMonitor.

• Check if the ServiceMonitor and the Prometheus Operator are in the same namespace.

• Ensure the ServiceMonitor is created in the correct namespace.

• Verify the Prometheus Operator is deployed in the expected namespace.

• If they are in different namespaces, either move the ServiceMonitor or deploy the Prometheus Operator in the same namespace.

Reason #2: Label or Selector Mismatch

Here's how to troubleshoot this.

• Verify that the labels and selectors specified in the ServiceMonitor match the labels and selectors of the target application.

• Use the following command to compare the labels and selectors:

kubectl get servicemonitors -n <namespace> <servicemonitor-name> -o yaml

• Make sure the labels and selectors are correctly configured and match the desired targets.

Reason #3: ServiceMonitor Creation Failure

If this is the reason the Prometheus Operator not picking up ServiceMonitor, here's how to go about fixing it.

• Check if the ServiceMonitor resource was created successfully.

• Run the following command to list all ServiceMonitors in the target namespace:

kubectl get servicemonitors -n <namespace>

• Verify that the ServiceMonitor you created is listed and has an "Active" status.

• If it's not listed or has an error status, check for any error messages in the Kubernetes events or the Operator's logs.

Reason #4: Prometheus Configuration Issues

If this is the reason you are getting the above error, here's how you can troubleshoot.

• Check the Prometheus configuration to ensure it includes the appropriate labels and selectors to discover and scrape the desired targets.
• Use the following command to inspect the Prometheus configuration:

kubectl get prometheus -n <namespace> <prometheus-instance> -o yaml

• Look for the serviceMonitorSelector field and verify that it matches the labels specified in the ServiceMonitor.

• If necessary, update the Prometheus configuration to include the correct labels and selectors.

Reason #5. Prometheus Operator Version Compatibility

Here are the troubleshooting steps if this is the case.

• If you recently upgraded or changed the Prometheus Operator version, ensure that the ServiceMonitor resource is compatible with the new version.

• Check the release notes or documentation of the Prometheus Operator for any changes or updates that might require adjustments in your ServiceMonitor configuration.

• If necessary, update the ServiceMonitor to comply with the requirements of the new Prometheus Operator version.

Reason #6: RBAC Permission Issues

If this is the reason the Prometheus Operator not picking up ServiceMonitor, here's how to go about fixing it.

• Verify that the service account used by the Prometheus Operator has sufficient permissions to access and discover the ServiceMonitor resource.

• Check the RBAC configuration and ensure the service account has read access to ServiceMonitors and related resources in the target namespace.

• If necessary, update the RBAC configuration to grant the required permissions to the Prometheus Operator's service account.

These are some possible examples and troubleshooting steps to help you diagnose and resolve the issue when the Prometheus Operator is not picking up a ServiceMonitor.

Remember to review the specific details of your deployment and consult the relevant documentation or resources for further guidance.

Also Read: Docker Commands Cheat Sheet

FAQ

What is the Prometheus operator for the Kubernetes cluster?

The Prometheus Operator is a tool for automating the deployment and management of Prometheus and related monitoring components in Kubernetes clusters. It simplifies monitoring setup, configuration, and maintenance tasks, making implementing efficient monitoring and alerting in Kubernetes environments easier.

What is the advantage of the Prometheus operator?

The Prometheus Operator simplifies the setup and management of Prometheus in Kubernetes, automates configuration tasks, and improves scalability and high availability for monitoring.

What is the difference between the Grafana operator and the Prometheus operator?

The Prometheus Operator manages Prometheus and monitoring components, while the Grafana Operator handles Grafana and visualization capabilities in Kubernetes.

Share with friends

Written by Priyansh Khodiyar

TwitterLinkedIn

Priyansh is the founder of UnYAML and a software engineer with a passion for writing. He has good experience with writing and working around DevOps tools and technologies, APMs, Kubernetes APIs, etc and loves to share his knowledge with others.

Further Reading