Carvel Tooling for Java Apps: Modern Kubernetes Application Management

Carvel is a suite of reliable, single-purpose, composable tools for building, configuring, and deploying applications to Kubernetes. This guide covers integrating Carvel tools with Java applications for superior Kubernetes deployment experiences.

Table of Contents

Core Concepts

What is Carvel?

Suite of Kubernetes application management tools
Composable, single-purpose tools
GitOps-friendly approach
Alternative to Helm/Kustomize

Key Carvel Tools:

ytt: YAML templating tool
kbld: Image building and resolution
kapp: Application deployment tool
imgpkg: Image packaging for configuration
vendir: Declarative directory contents

Dependencies and Setup

1. Installation

# Install Carvel tools on macOS
brew tap vmware-tanzu/carvel
brew install ytt kbld kapp imgpkg vendir
# Install on Linux
wget -O- https://carvel.dev/install.sh | bash
# Verify installation
ytt version
kbld version
kapp version

2. Project Structure

java-carvel-app/
├── build/
│   └── carvel/
├── k8s/
│   ├── base/
│   ├── overlays/
│   └── values/
├── src/
├── build.gradle
├── Dockerfile
└── carvel-build.sh

Core Implementation

1. Basic Kubernetes Manifests

# k8s/base/deployment.yml
apiVersion: apps/v1
kind: Deployment
metadata:
name: java-app
labels:
app: java-app
spec:
replicas: 2
selector:
matchLabels:
app: java-app
template:
metadata:
labels:
app: java-app
spec:
containers:
- name: java-app
image: placeholder # Will be replaced by kbld
ports:
- containerPort: 8080
env:
- name: JAVA_OPTS
value: "-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"
resources:
requests:
memory: "512Mi"
cpu: "250m"
limits:
memory: "1024Mi"
cpu: "500m"
livenessProbe:
httpGet:
path: /actuator/health/liveness
port: 8080
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /actuator/health/readiness
port: 8080
initialDelaySeconds: 5
periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
name: java-app-service
spec:
selector:
app: java-app
ports:
- port: 80
targetPort: 8080
type: ClusterIP

2. ytt Templating for Java Apps

# k8s/base/config.yml
#@ load("@ytt:data", "data")
#@ load("@ytt:struct", "struct")
#@ def app_config():
apiVersion: v1
kind: ConfigMap
metadata:
name: java-app-config
data:
application.yml: |
server:
port: 8080
spring:
application:
name: #@ data.values.app_name
datasource:
url: #@ data.values.database.url
username: #@ data.values.database.username
password: #@ data.values.database.password
jpa:
hibernate:
ddl-auto: validate
show-sql: false
management:
endpoints:
web:
exposure:
include: health,info,metrics
endpoint:
health:
show-details: always
probes:
enabled: true
#@ end
#@ def secret_template():
apiVersion: v1
kind: Secret
metadata:
name: java-app-secrets
type: Opaque
data:
database.password: #@ data.values.database.password_b64
encryption.key: #@ data.values.encryption_key_b64
#@ end
--- #@ app_config()
--- #@ secret_template()

3. Values Configuration

# k8s/values/defaults.yml
#@data/values
---
app_name: "java-carvel-app"
environment: "development"
replicas: 2
database:
url: "jdbc:postgresql://localhost:5432/myapp"
username: "appuser"
password: "defaultpass"
password_b64: "ZGVmYXVsdHBhc3M="
encryption_key_b64: "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo="
resources:
requests:
memory: "512Mi"
cpu: "250m"
limits:
memory: "1024Mi"
cpu: "500m"

4. Environment Overlays

# k8s/overlays/staging/values.yml
#@data/values
---
app_name: "java-carvel-app-staging"
environment: "staging"
replicas: 3
database:
url: "jdbc:postgresql://postgresql-staging:5432/myapp"
username: "appuser"
password: "stagingpass"
password_b64: "c3RhZ2luZ3Bhc3M="
resources:
requests:
memory: "1Gi"
cpu: "500m"
limits:
memory: "2Gi"
cpu: "1000m"

# k8s/overlays/production/values.yml
#@data/values
---
app_name: "java-carvel-app-production"
environment: "production"
replicas: 5
database:
url: "jdbc:postgresql://postgresql-production:5432/myapp"
username: "appuser"
password: "prodpass"
password_b64: "cHJvZHBhc3M="
resources:
requests:
memory: "2Gi"
cpu: "1000m"
limits:
memory: "4Gi"
cpu: "2000m"

5. Build Configuration with kbld

# build/carvel/kbld-config.yml
apiVersion: kbld.k14s.io/v1alpha1
kind: Config
sources:
- image: java-app
path: .
docker:
build:
dockerfile: Dockerfile
target: builder
destinations:
- image: ghcr.io/myorg/java-carvel-app
overrides:
- image: placeholder
newImage: java-app
preresolved: true

6. Dockerfile for Carvel Integration

# Multi-stage build optimized for Carvel
FROM eclipse-temurin:17-jdk-alpine as builder
WORKDIR /app
# Copy build files
COPY gradlew .
COPY gradle gradle
COPY build.gradle settings.gradle ./
# Download dependencies
RUN ./gradlew dependencies --no-daemon
# Copy source and build
COPY src src
RUN ./gradlew bootJar --no-daemon
# Extract layers for better container startup
RUN java -Djarmode=tools -jar build/libs/*.jar extract --destination build/extracted
# Runtime image
FROM eclipse-temurin:17-jre-alpine
RUN addgroup -S appuser && adduser -S appuser -G appuser
USER appuser
WORKDIR /app
# Copy extracted layers
COPY --from=builder /app/build/extracted/dependencies/ ./
COPY --from=builder /app/build/extracted/spring-boot-loader/ ./
COPY --from=builder /app/build/extracted/snapshot-dependencies/ ./
COPY --from=builder /app/build/extracted/application/ ./
EXPOSE 8080
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]

Build and Deployment Scripts

1. Carvel Build Script

#!/bin/bash
# carvel-build.sh
set -e
APP_NAME="java-carvel-app"
IMAGE_REPO="ghcr.io/myorg"
TAG="${1:-latest}"
ENVIRONMENT="${2:-development}"
echo "Building Java application with Carvel tools..."
echo "Environment: $ENVIRONMENT"
echo "Tag: $TAG"
# Build JAR
echo "=== Building Java Application ==="
./gradlew clean bootJar
# Build Docker image
echo "=== Building Docker Image ==="
docker build -t ${APP_NAME}:${TAG} .
# Use kbld to resolve images and create lock file
echo "=== Processing Kubernetes Manifests ==="
mkdir -p build/carvel
kbld -f build/carvel/kbld-config.yml \
--images-annotation=false \
> build/carvel/kbld-resolved.yml
# Package application bundle with imgpkg
echo "=== Creating Application Bundle ==="
imgpkg push -b ${IMAGE_REPO}/${APP_NAME}-bundle:${TAG} \
--file build/carvel/kbld-resolved.yml
echo "Build completed successfully!"
echo "Bundle: ${IMAGE_REPO}/${APP_NAME}-bundle:${TAG}"

2. Deployment Script

#!/bin/bash
# carvel-deploy.sh
set -e
APP_NAME="java-carvel-app"
IMAGE_REPO="ghcr.io/myorg"
TAG="${1:-latest}"
ENVIRONMENT="${2:-development}"
KAPP_NAMESPACE="${3:-default}"
echo "Deploying Java application with Carvel..."
echo "Environment: $ENVIRONMENT"
echo "Namespace: $KAPP_NAMESPACE"
# Create namespace if it doesn't exist
kubectl create namespace $KAPP_NAMESPACE --dry-run=client -o yaml | kubectl apply -f -
# Pull bundle and deploy with kapp
echo "=== Deploying Application ==="
# Template with ytt and deploy with kapp
kapp deploy -a ${APP_NAME}-${ENVIRONMENT} \
--into-ns $KAPP_NAMESPACE \
--file <(ytt -f k8s/base \
-f k8s/overlays/${ENVIRONMENT} \
-f build/carvel/kbld-resolved.yml \
-v environment=${ENVIRONMENT}) \
--diff-changes \
--yes
echo "Deployment completed successfully!"
echo "To inspect: kapp inspect -a ${APP_NAME}-${ENVIRONMENT}"
echo "To view logs: kubectl logs -l app=${APP_NAME} -n ${KAPP_NAMESPACE}"

3. Complete Build Pipeline

#!/bin/bash
# carvel-pipeline.sh
set -e
# Configuration
APP_NAME="java-carvel-app"
IMAGE_REPO="ghcr.io/myorg"
VERSION=${1:-$(git rev-parse --short HEAD)}
ENVIRONMENTS=("development" "staging" "production")
echo "Starting Carvel pipeline for version: $VERSION"
# Build application
echo "=== Phase 1: Application Build ==="
./carvel-build.sh $VERSION
# Deploy to environments
for ENV in "${ENVIRONMENTS[@]}"; do
echo "=== Deploying to $ENV ==="
# For production, require manual approval
if [ "$ENV" == "production" ]; then
read -p "Deploy to production? (y/n): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo "Skipping production deployment"
continue
fi
fi
./carvel-deploy.sh $VERSION $ENV $APP_NAME-$ENV
done
echo "Pipeline completed successfully!"

Advanced Carvel Patterns

1. Multi-Application Configuration

# k8s/base/database.yml
#@ load("@ytt:data", "data")
#@ if data.values.enable_database:
apiVersion: apps/v1
kind: Deployment
metadata:
name: postgresql
labels:
app: postgresql
component: database
spec:
replicas: 1
selector:
matchLabels:
app: postgresql
template:
metadata:
labels:
app: postgresql
spec:
containers:
- name: postgresql
image: postgres:13
env:
- name: POSTGRES_DB
value: #@ data.values.database.name
- name: POSTGRES_USER
value: #@ data.values.database.username
- name: POSTGRES_PASSWORD
valueFrom:
secretKeyRef:
name: java-app-secrets
key: database.password
ports:
- containerPort: 5432
volumeMounts:
- name: postgresql-data
mountPath: /var/lib/postgresql/data
resources:
requests:
memory: "256Mi"
cpu: "100m"
limits:
memory: "512Mi"
cpu: "200m"
volumes:
- name: postgresql-data
persistentVolumeClaim:
claimName: postgresql-pvc
---
apiVersion: v1
kind: Service
metadata:
name: postgresql
spec:
selector:
app: postgresql
ports:
- port: 5432
targetPort: 5432
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: postgresql-pvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi
#@ end

2. Feature Flags with ytt

# k8s/base/features.yml
#@ load("@ytt:data", "data")
#@ def feature_flags():
apiVersion: v1
kind: ConfigMap
metadata:
name: feature-flags
data:
features.yml: |
features:
new-payment-service:
enabled: #@ data.values.features.new_payment_service
experimental-ui:
enabled: #@ data.values.features.experimental_ui
maintenance-mode:
enabled: #@ data.values.features.maintenance_mode
logging:
level: #@ data.values.logging.level
#@ end
--- #@ feature_flags()

3. Java-Specific Health Checks

# k8s/base/healthchecks.yml
#@ load("@ytt:overlay", "overlay")
#@ def add_healthchecks():
#@overlay/match by=overlay.subset({"kind": "Deployment"})
---
spec:
template:
spec:
containers:
#@overlay/match by=overlay.subset({"name": "java-app"})
- name: java-app
livenessProbe:
httpGet:
path: /actuator/health/liveness
port: 8080
initialDelaySeconds: 90
periodSeconds: 10
timeoutSeconds: 5
failureThreshold: 3
readinessProbe:
httpGet:
path: /actuator/health/readiness
port: 8080
initialDelaySeconds: 30
periodSeconds: 5
timeoutSeconds: 3
failureThreshold: 3
startupProbe:
httpGet:
path: /actuator/health/readiness
port: 8080
initialDelaySeconds: 10
periodSeconds: 5
timeoutSeconds: 3
failureThreshold: 30
#@ end
--- #@ add_healthchecks()

4. Resource Management

# k8s/base/resources.yml
#@ load("@ytt:overlay", "overlay")
#@ load("@ytt:data", "data")
#@ def add_resources():
#@overlay/match by=overlay.subset({"kind": "Deployment"})
---
spec:
template:
spec:
containers:
#@overlay/match by=overlay.subset({"name": "java-app"})
- name: java-app
resources:
requests:
memory: #@ data.values.resources.requests.memory
cpu: #@ data.values.resources.requests.cpu
limits:
memory: #@ data.values.resources.limits.memory
cpu: #@ data.values.resources.limits.cpu
env:
- name: JAVA_OPTS
value: #@ "-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0 -Xmx" + data.values.resources.limits.memory.replace("Mi", "m").replace("Gi", "g")
#@ end
--- #@ add_resources()

CI/CD Integration

1. GitHub Actions with Carvel

# .github/workflows/carvel-pipeline.yml
name: Carvel Java Pipeline
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
env:
APP_NAME: java-carvel-app
IMAGE_REPO: ghcr.io/${{ github.repository }}
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up JDK 17
uses: actions/setup-java@v3
with:
java-version: '17'
distribution: 'temurin'
- name: Run tests
run: ./gradlew test
build:
needs: test
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Install Carvel tools
run: |
wget -O- https://carvel.dev/install.sh | bash
ytt version
kbld version
kapp version
- name: Build with Carvel
run: |
chmod +x carvel-build.sh
./carvel-build.sh ${{ github.sha }}
- name: Push to GitHub Container Registry
run: |
echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
docker push $IMAGE_REPO/$APP_NAME-bundle:${{ github.sha }}
deploy-staging:
needs: build
runs-on: ubuntu-latest
environment: staging
steps:
- uses: actions/checkout@v4
- name: Install Carvel tools
run: wget -O- https://carvel.dev/install.sh | bash
- name: Deploy to staging
run: |
chmod +x carvel-deploy.sh
./carvel-deploy.sh ${{ github.sha }} staging $APP_NAME-staging
env:
KUBE_CONFIG: ${{ secrets.STAGING_KUBE_CONFIG }}

2. GitLab CI with Carvel

# .gitlab-ci.yml
variables:
APP_NAME: "java-carvel-app"
stages:
- test
- build
- deploy
.test_template: &test_template
stage: test
image: eclipse-temurin:17
before_script:
- chmod +x gradlew
script:
- ./gradlew test
test:
<<: *test_template
build:
stage: build
image: docker:20.10
services:
- docker:20.10-dind
before_script:
- apk add --no-cache curl
- wget -O- https://carvel.dev/install.sh | bash
script:
- docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
- chmod +x carvel-build.sh
- ./carvel-build.sh $CI_COMMIT_SHA
only:
- main
- develop
deploy-staging:
stage: deploy
image: alpine:3.16
before_script:
- apk add --no-cache curl kubectl
- wget -O- https://carvel.dev/install.sh | bash
script:
- echo "$KUBE_CONFIG_STAGING" | base64 -d > /tmp/kubeconfig
- export KUBECONFIG=/tmp/kubeconfig
- chmod +x carvel-deploy.sh
- ./carvel-deploy.sh $CI_COMMIT_SHA staging $APP_NAME-staging
environment:
name: staging
only:
- main

Monitoring and Operations

1. Application Monitoring

# k8s/base/monitoring.yml
#@ load("@ytt:data", "data")
#@ if data.values.monitoring.enabled:
apiVersion: v1
kind: Service
metadata:
name: java-app-metrics
labels:
app: java-app
component: metrics
spec:
selector:
app: java-app
ports:
- name: metrics
port: 8080
targetPort: 8080
---
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
name: java-app-monitor
labels:
app: java-app
spec:
selector:
matchLabels:
app: java-app
endpoints:
- port: metrics
path: /actuator/prometheus
interval: 30s
#@ end

2. Logging Configuration

# k8s/base/logging.yml
#@ load("@ytt:overlay", "overlay")
#@ def add_logging():
#@overlay/match by=overlay.subset({"kind": "Deployment"})
---
spec:
template:
metadata:
annotations:
fluentbit.io/parser: java
spec:
containers:
#@overlay/match by=overlay.subset({"name": "java-app"})
- name: java-app
env:
- name: LOGGING_LEVEL
value: #@ data.values.logging.level
- name: LOGGING_PATTERN
value: "%d{yyyy-MM-dd HH:mm:ss} - %logger{36} - %msg%n"
#@ end
--- #@ add_logging()

3. kapp Application Management

#!/bin/bash
# carvel-manage.sh
APP_NAME="java-carvel-app"
ENVIRONMENT="${1:-development}"
ACTION="${2:-status}"
case $ACTION in
"status")
kapp inspect -a ${APP_NAME}-${ENVIRONMENT}
;;
"logs")
kubectl logs -l app=${APP_NAME} -n ${APP_NAME}-${ENVIRONMENT} --tail=100
;;
"restart")
kapp deploy -a ${APP_NAME}-${ENVIRONMENT} --yes
;;
"delete")
kapp delete -a ${APP_NAME}-${ENVIRONMENT} --yes
;;
"diff")
kapp deploy -a ${APP_NAME}-${ENVIRONMENT} --diff-changes --yes
;;
*)
echo "Usage: $0 [environment] [status|logs|restart|delete|diff]"
;;
esac

Best Practices for Java Applications

1. JVM Optimization in Kubernetes

# k8s/base/jvm-optimization.yml
#@ load("@ytt:overlay", "overlay")
#@ load("@ytt:data", "data")
#@ def jvm_optimization():
#@overlay/match by=overlay.subset({"kind": "Deployment"})
---
spec:
template:
spec:
containers:
#@overlay/match by=overlay.subset({"name": "java-app"})
- name: java-app
env:
- name: JAVA_TOOL_OPTIONS
value: #@ |
-XX:+UseContainerSupport
-XX:MaxRAMPercentage=75.0
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-Xlog:gc*:file=/tmp/gc.log:time,uptime,level,tags:filecount=5,filesize=10m
-Djava.security.egd=file:/dev/./urandom
-Dspring.profiles.active=#@ data.values.environment
- name: SPRING_PROFILES_ACTIVE
value: #@ data.values.environment
#@ end
--- #@ jvm_optimization()

2. Security Hardening

# k8s/base/security.yml
#@ load("@ytt:overlay", "overlay")
#@ def security_hardening():
#@overlay/match by=overlay.subset({"kind": "Deployment"})
---
spec:
template:
spec:
securityContext:
runAsNonRoot: true
runAsUser: 1000
runAsGroup: 1000
fsGroup: 1000
containers:
#@overlay/match by=overlay.subset({"name": "java-app"})
- name: java-app
securityContext:
allowPrivilegeEscalation: false
capabilities:
drop:
- ALL
readOnlyRootFilesystem: true
runAsNonRoot: true
runAsUser: 1000
volumeMounts:
- name: tmp
mountPath: /tmp
- name: logs
mountPath: /app/logs
volumes:
- name: tmp
emptyDir: {}
- name: logs
emptyDir: {}
#@ end
--- #@ security_hardening()

3. Database Migration Job

# k8s/base/migration.yml
#@ load("@ytt:data", "data")
#@ if data.values.run_migrations:
apiVersion: batch/v1
kind: Job
metadata:
name: java-app-migration
labels:
app: java-app
component: migration
spec:
template:
metadata:
labels:
app: java-app
component: migration
spec:
containers:
- name: migration
image: #@ data.values.image
command: ["java", "-jar", "/app/app.jar", "--spring.profiles.active=migration"]
env:
- name: SPRING_PROFILES_ACTIVE
value: "migration"
- name: SPRING_DATASOURCE_URL
value: #@ data.values.database.url
- name: SPRING_DATASOURCE_USERNAME
value: #@ data.values.database.username
- name: SPRING_DATASOURCE_PASSWORD
valueFrom:
secretKeyRef:
name: java-app-secrets
key: database.password
resources:
requests:
memory: "512Mi"
cpu: "250m"
limits:
memory: "1Gi"
cpu: "500m"
restartPolicy: Never
backoffLimit: 2
#@ end

Troubleshooting and Debugging

1. Debug Scripts

#!/bin/bash
# carvel-debug.sh
APP_NAME="java-carvel-app"
ENVIRONMENT="${1:-development}"
echo "=== Debugging $APP_NAME in $ENVIRONMENT ==="
echo "1. Application Status"
kapp inspect -a ${APP_NAME}-${ENVIRONMENT}
echo -e "\n2. Pod Status"
kubectl get pods -n ${APP_NAME}-${ENVIRONMENT}
echo -e "\n3. Recent Events"
kubectl get events -n ${APP_NAME}-${ENVIRONMENT} --sort-by=.lastTimestamp | tail -10
echo -e "\n4. Application Logs"
kubectl logs -l app=${APP_NAME} -n ${APP_NAME}-${ENVIRONMENT} --tail=50
echo -e "\n5. Resource Usage"
kubectl top pods -n ${APP_NAME}-${ENVIRONMENT} 2>/dev/null || echo "Metrics not available"
echo -e "\n6. Configuration"
kubectl get configmap java-app-config -n ${APP_NAME}-${ENVIRONMENT} -o yaml

2. Validation Script

#!/bin/bash
# carvel-validate.sh
echo "=== Validating Carvel Configuration ==="
# Validate ytt templates
echo "1. Validating ytt templates..."
ytt -f k8s/base -f k8s/values/defaults.yml > /dev/null
echo "✓ ytt templates are valid"
# Validate Kubernetes manifests
echo "2. Validating Kubernetes manifests..."
ytt -f k8s/base -f k8s/values/defaults.yml | kubectl apply --dry-run=client -f -
echo "✓ Kubernetes manifests are valid"
# Check for required values
echo "3. Checking required configurations..."
if [ -z "$IMAGE_REPO" ]; then
echo "✗ IMAGE_REPO is not set"
exit 1
fi
echo "✓ Required configurations are set"
echo "Validation completed successfully!"

Migration from Traditional Tools

1. Migration from Helm

# Convert Helm values to ytt values
helm template my-app ./chart --values values.yaml --dry-run > helm-output.yaml
# Create equivalent ytt structure
mkdir -p k8s/{base,overlays,values}
# Manually convert Helm templates to ytt templates

2. Migration from Kustomize

# Kustomize patches can be converted to ytt overlays
# kustomization.yaml patches become ytt overlay files

Conclusion

Carvel provides Java applications with:

Reliable Templating: Type-safe YAML templating with ytt
Image Management: Deterministic image resolution with kbld
Safe Deployments: Atomic application deployment with kapp
Configuration Packaging: Immutable configuration bundles with imgpkg
GitOps Ready: Composable tools that work well with GitOps workflows

By implementing Carvel tooling for Java applications, you achieve:

Reproducible builds across environments
Safe, atomic deployments with rollback capabilities
Configuration as code with proper templating
Better separation of concerns between dev and ops
Superior Kubernetes experience compared to traditional tools

The combination of Carvel's composable tools with Java's robust ecosystem creates a powerful platform for modern cloud-native application deployment and management.

Pyroscope Profiling in Java
Explains how to use Pyroscope for continuous profiling in Java applications, helping developers analyze CPU and memory usage patterns to improve performance and identify bottlenecks.
https://macronepal.com/blog/pyroscope-profiling-in-java/

OpenTelemetry Metrics in Java: Comprehensive Guide
Provides a complete guide to collecting and exporting metrics in Java using OpenTelemetry, including counters, histograms, gauges, and integration with monitoring tools. (MACRO NEPAL)
https://macronepal.com/blog/opentelemetry-metrics-in-java-comprehensive-guide/

OTLP Exporter in Java: Complete Guide for OpenTelemetry
Explains how to configure OTLP exporters in Java to send telemetry data such as traces, metrics, and logs to monitoring systems using HTTP or gRPC protocols. (MACRO NEPAL)
https://macronepal.com/blog/otlp-exporter-in-java-complete-guide-for-opentelemetry/

Thanos Integration in Java: Global View of Metrics
Explains how to integrate Thanos with Java monitoring systems to create a scalable global metrics view across multiple Prometheus instances.

https://macronepal.com/blog/thanos-integration-in-java-global-view-of-metrics

Time Series with InfluxDB in Java: Complete Guide (Version 2)
Explains how to manage time-series data using InfluxDB in Java applications, including storing, querying, and analyzing metrics data.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide-2

Time Series with InfluxDB in Java: Complete Guide
Provides an overview of integrating InfluxDB with Java for time-series data handling, including monitoring applications and managing performance metrics.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide

Implementing Prometheus Remote Write in Java (Version 2)
Explains how to configure Java applications to send metrics data to Prometheus-compatible systems using the remote write feature for scalable monitoring.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide-2

Implementing Prometheus Remote Write in Java: Complete Guide
Provides instructions for sending metrics from Java services to Prometheus servers, enabling centralized monitoring and real-time analytics.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide

Building a TileServer GL in Java: Vector and Raster Tile Server
Explains how to build a TileServer GL in Java for serving vector and raster map tiles, useful for geographic visualization and mapping applications.

https://macronepal.com/blog/building-a-tileserver-gl-in-java-vector-and-raster-tile-server

Indoor Mapping in Java
Explains how to create indoor mapping systems in Java, including navigation inside buildings, spatial data handling, and visualization techniques.