Integrating ArangoDB with Kubernetes for Seamless Deployment
Estimated reading time: 6 minutes
Are you a database architect or DevOps architect tasked with deploying modern databases like ArangoDB on Kubernetes? Kubernetes, with its robust orchestration capabilities, provides a solid foundation for managing containerized workloads, ensuring reliability and adaptability for database deployments.
In this post, we’ll guide you through the process of deploying ArangoDB on Kubernetes, addressing common DevOps challenges like scalability, high availability, and efficient resource utilization. By the end, you'll have a practical understanding of integrating ArangoDB with Kubernetes in a way that’s both robust and future-proof.
Why ArangoDB and Kubernetes?
ArangoDB, as a multi-model database, excels at handling diverse workloads—be it document, graph, or key-value data. When paired with Kubernetes, you gain:
- Scalability: Automatically adjust resources to meet demand.
- Resilience: Ensure high availability through self-healing capabilities.
- Simplicity: Streamline deployment and updates with Infrastructure as Code (IaC).
- Automation: Minimize manual intervention with Kubernetes' built-in orchestration.
Prerequisites
Before diving into deployment, ensure you have the following ready:
- A Kubernetes Cluster: Local (e.g., Minikube) or cloud-based (e.g., AWS EKS, GKE).
- kubectl: Installed and configured to interact with your cluster.
- Helm: Installed for managing Kubernetes charts.
Step 1: Installing the ArangoDB Kubernetes Operator
The ArangoDB Kubernetes Operator simplifies the deployment and management of ArangoDB clusters. It automates tasks like scaling, failover, and configuration management.
Add the Helm Repository
Start by adding the ArangoDB Helm repository:
bash
helm repo update
Deploy the Operator
Install the ArangoDB operator in a dedicated namespace:
bash
This deploys the operator, which manages the lifecycle of your ArangoDB cluster.
Step 2: Configuring and Deploying an ArangoDB Cluster
Create the Cluster Configuration
Write a configuration file ( e.g., arangodb-cluster.yaml ) to define your cluster. This configuration outlines the desired topology, resource allocation, and environment settings.
Yaml
kind: ArangoDeployment
metadata:
name: arango-cluster
namespace: arangodb
spec:
mode: Cluster
environment: Production
image:
repository: arangodb/arangodb
tag: latest
tls:
mode: None
authentication:
jwtSecretName: arango-cluster-jwt
agents:
count: 3
resources:
requests:
memory: 1Gi
cpu: 500m
dbservers:
count: 3
resources:
requests:
memory: 2Gi
cpu: 500m
coordinators:
count: 2
resources:
requests:
memory: 1Gi
cpu: 500m
Apply the Configuration
Deploy your cluster by applying the YAML file:
bash
Verify the deployment status:
bash
Step 3: Addressing DevOps Concerns
Scalability
Kubernetes' horizontal scaling ensures that your ArangoDB cluster can handle fluctuating workloads:
bash
High Availability
With ArangoDB's fault-tolerant architecture and Kubernetes' self-healing, you minimize downtime. For example, Kubernetes automatically restarts failed pods:
bash
Backup and Recovery
Set up a backup strategy using Kubernetes CronJobs:
yaml
kind: CronJob
metadata:
name: arango-backup
namespace: arangodb
spec:
schedule: "0 2 * * *"
jobTemplate:
spec:
template:
spec:
containers:
- name: arango-backup
image: arangodb/arangodb
command: ["arangodump"]
args:
- "--output-directory=/backups"
- "--server.database=mydb"
restartPolicy: OnFailure
Step 4: Monitoring and Maintenance
Use Kubernetes-native tools like Prometheus and Grafana to monitor your ArangoDB deployment. Enable metrics collection by annotating your pods:
yaml
annotations:
prometheus.io/scrape: "true"
prometheus.io/port: "8529"
Summary
Integrating ArangoDB with Kubernetes offers an elegant solution for managing complex database workloads. By leveraging Kubernetes' orchestration capabilities, you can ensure your database is scalable, resilient, and easy to manage. Whether you're a seasoned DevOps professional or new to container orchestration, this setup will provide a reliable foundation for your ArangoDB deployment.
Happy deploying!
Celebrating Kube-ArangoDB’s 1.0 Release!
Estimated reading time: 4 minutes
Kube-ArangoDB, ArangoDB’s Kubernetes Operator first released two years ago and as of today is operating many ArangoDB production clusters (including ArangoDB’s Managed Service ArangoGraph). With many exciting features we felt kube-arango really deserves to be released as 1.0.
ArangoDB and the Cloud-Native Ecosystem: Integration Insights
ArangoDB is joining CNCF to continue its focus on providing a scalable native multi-model database, supporting Graph, Document, and Key-Value data models in the Cloud Native ecosystem.
ArangoDB
ArangoDB is a scalable multi-model model database. What does that mean?
You might have already encountered different NoSQL databases specialized for different data models e.g., graph or document databases. However most real-life use-cases actually require a combination of different data models like Single View of Everything, Machine Learning or even Case Management projects to name but a few.
In such scenarios, single data model databases typically require merging data from different databases and often even reimplementing some database logic in the application layer as well as the effort to operate multiple database in a production environment.
Building Our Managed Service on Kubernetes: ArangoDB Insights
Running distributed databases on-prem or in the cloud is always a challenge. Over the past years, we have invested a lot to make cluster deployments as simple as possible, both on traditional (virtual) machines (using the ArangoDB Starter) as well as on modern orchestration systems such as Kubernetes (using Kube-ArangoDB).
However, as long as teams have to run databases themselves, the burden of deploying, securing, monitoring, maintaining & upgrading can only be reduced to a certain extent but not avoided.
For this reason, we built ArangoDB ArangoGraph.
Read more
Deploying ArangoDB 3.4 on Kubernetes
It has been a few months since we first released the Kubernetes operator for ArangoDB and started to brag about it. Since then, quite a few things have happened.
For example, we have done a lot of testing, fixed bugs, and by now the operator is declared to be production ready for three popular public Kubernetes offerings, namely Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS) and Pivotal Kubernetes Service (PKS) (see here for the current state of affairs). Read more
The ArangoDB Operator for Kubernetes – Stateful Cluster Deployments in 5min
At ArangoDB we’ve got many requests for running our database on Kubernetes. This makes complete sense since Kubernetes is a highly popular system for deploying, scaling and managing containerized applications.
Running any stateful application on Kubernetes is a bit more involved than running a stateless application, because of the storage requirements and potentially other requirements such as static network addresses. Running a database on Kubernetes combines all the challenges of running a stateful application, combined with a quest for optimal performance.
This article explains what is needed to run ArangoDB on Kubernetes and what we’re doing to make it a lot easier.
Interested in trying out ArangoDB? Fire up your database in just a few clicks with ArangoDB ArangoGraph: the Cloud Service for ArangoDB. Start your free 14-day trial here. Read more
Get the latest tutorials,
blog posts and news:
Thanks for subscribing! Please check your email for further instructions.