How do I deploy VictoriaMetrics with MinIO on Kubernetes?

In this guide, we will deploy VictoriaMetrics, a high-performance, cost-effective, and scalable monitoring solution, along with MinIO, a high-performance object storage service, on a Kubernetes cluster using Pulumi. We will define the necessary Kubernetes resources, including namespaces, deployments, and services, to set up both VictoriaMetrics and MinIO.

Key Points

Deploy VictoriaMetrics for monitoring.
Deploy MinIO for object storage.
Use Pulumi to manage Kubernetes resources.

import * as pulumi from "@pulumi/pulumi";
import * as k8s from "@pulumi/kubernetes";

// Create a namespace for VictoriaMetrics
const vmNamespace = new k8s.core.v1.Namespace("victoria-metrics-ns", {
    metadata: { name: "victoria-metrics" },
});

// Create a namespace for MinIO
const minioNamespace = new k8s.core.v1.Namespace("minio-ns", {
    metadata: { name: "minio" },
});

// Deploy MinIO
const minioDeployment = new k8s.apps.v1.Deployment("minio-deployment", {
    metadata: {
        namespace: minioNamespace.metadata.name,
        name: "minio",
    },
    spec: {
        selector: { matchLabels: { app: "minio" } },
        template: {
            metadata: { labels: { app: "minio" } },
            spec: {
                containers: [
                    {
                        name: "minio",
                        image: "minio/minio:latest",
                        args: ["server", "/data"],
                        ports: [{ containerPort: 9000 }],
                        env: [
                            { name: "MINIO_ACCESS_KEY", value: "minioadmin" },
                            { name: "MINIO_SECRET_KEY", value: "minioadmin" },
                        ],
                        volumeMounts: [
                            {
                                name: "data",
                                mountPath: "/data",
                            },
                        ],
                    },
                ],
                volumes: [
                    {
                        name: "data",
                        emptyDir: {},
                    },
                ],
            },
        },
    },
});

// Expose MinIO service
const minioService = new k8s.core.v1.Service("minio-service", {
    metadata: {
        namespace: minioNamespace.metadata.name,
        name: "minio",
    },
    spec: {
        selector: { app: "minio" },
        ports: [
            { port: 9000, targetPort: 9000, protocol: "TCP" },
        ],
        type: "ClusterIP",
    },
});

// Deploy VictoriaMetrics
const victoriaMetricsDeployment = new k8s.apps.v1.Deployment("victoria-metrics-deployment", {
    metadata: {
        namespace: vmNamespace.metadata.name,
        name: "victoria-metrics",
    },
    spec: {
        selector: { matchLabels: { app: "victoria-metrics" } },
        template: {
            metadata: { labels: { app: "victoria-metrics" } },
            spec: {
                containers: [
                    {
                        name: "victoria-metrics",
                        image: "victoriametrics/victoria-metrics:latest",
                        ports: [{ containerPort: 8428 }],
                        args: ["-storageDataPath=/storage", "-retentionPeriod=1"],
                        volumeMounts: [
                            {
                                name: "storage",
                                mountPath: "/storage",
                            },
                        ],
                    },
                ],
                volumes: [
                    {
                        name: "storage",
                        emptyDir: {},
                    },
                ],
            },
        },
    },
});

// Expose VictoriaMetrics service
const victoriaMetricsService = new k8s.core.v1.Service("victoria-metrics-service", {
    metadata: {
        namespace: vmNamespace.metadata.name,
        name: "victoria-metrics",
    },
    spec: {
        selector: { app: "victoria-metrics" },
        ports: [
            { port: 8428, targetPort: 8428, protocol: "TCP" },
        ],
        type: "ClusterIP",
    },
});

Summary

In this guide, we deployed VictoriaMetrics and MinIO on a Kubernetes cluster using Pulumi. We created namespaces, deployments, and services for both applications. VictoriaMetrics is used for monitoring, while MinIO serves as object storage. This setup allows for a scalable and efficient monitoring solution with reliable storage capabilities.

Deploy this code

Want to deploy this code? Sign up for a free Pulumi account to deploy in a few clicks.

New to Pulumi?

Want to deploy this code? Sign up with Pulumi to deploy in a few clicks.