Complete production-ready application with Vue3, Golang, Docker, Kubernetes, and comprehensive observability stack
This tutorial demonstrates building and deploying a modern full-stack application with enterprise-grade DevOps practices, including service mesh, monitoring, logging, and distributed tracing.
- Frontend: Vue 3 + TypeScript + Vite + Modern tooling
- Backend: Golang + Gin + GraphQL + REST APIs
- Database: PostgreSQL with connection pooling
- Authentication: JWT-based authentication (ready to implement)
- Containerization: Multi-stage Docker builds with security hardening
- Orchestration: Kubernetes with Helm package management
- Local Development: Kind (Kubernetes in Docker)
- Cloud Deployment: Google Kubernetes Engine (GKE)
- Infrastructure as Code: Terraform with complete GCP setup
- CI/CD: GitHub Actions with automated testing and deployment
- Service Mesh: Istio for traffic management, security, and observability
- Metrics & Monitoring: Prometheus + Grafana with custom dashboards
- Distributed Tracing: Jaeger with OpenTelemetry instrumentation
- Centralized Logging: ELK Stack (Elasticsearch + Kibana + Fluent Bit)
- Service Visualization: Kiali for service mesh topology
- Alerting: AlertManager with intelligent alert routing
- High Availability: Multi-zone deployment with auto-scaling
- Security: mTLS, RBAC, network policies, and security scanning
- Performance: Load balancing, circuit breakers, and caching
- Reliability: Health checks, graceful shutdowns, and disaster recovery
├── frontend/ # Vue 3 application
├── backend/ # Golang API server
├── docker/ # Docker configurations
├── k8s/ # Kubernetes manifests
├── helm/ # Helm charts
├── terraform/ # Infrastructure as code
├── .github/ # GitHub Actions workflows
└── scripts/ # Utility scripts
- Docker Desktop
- Node.js 18+
- Go 1.21+
- kubectl
- helm
- kind
- terraform
- gcloud CLI
One-command setup with full observability stack:
make docker-setup && make dev-upStep-by-step setup:
# 1. Setup project and dependencies
make setup
# 2. Build optimized Docker images
make build-images
# 3. Start development environment
make dev-up
# 4. Deploy to local Kubernetes
make kind-setup && make kind-deploy
# 5. Deploy to production (GKE)
make gke-setup && make gke-deploy📖 See QUICK_START.md for detailed setup instructions and troubleshooting.
- Frontend Development
- Backend Development
- Docker Configuration
- Local Kubernetes with Kind
- Helm Charts
- Terraform Infrastructure
- GitHub Actions CI/CD
- Production Deployment
- Observability Stack
- Traffic Management: Intelligent routing, load balancing, and traffic splitting
- Security: Automatic mTLS, authentication, and authorization policies
- Observability: Built-in metrics, logs, and distributed tracing
- Resilience: Circuit breakers, retries, and fault injection
- Metrics Collection: Application and infrastructure metrics
- Visualization: Pre-built and custom dashboards
- Alerting: Intelligent alerting with AlertManager
- SLI/SLO Tracking: Service level indicators and objectives
- Request Tracing: End-to-end request flow visualization
- Performance Analysis: Latency analysis and bottleneck identification
- Service Dependencies: Service interaction mapping
- Error Analysis: Trace-level error investigation
- Log Aggregation: Centralized log collection from all services
- Search & Analysis: Powerful log search and analysis with Elasticsearch
- Visualization: Log dashboards and analytics with Kibana
- Real-time Processing: Stream processing with Fluent Bit
- Service Topology: Real-time service mesh visualization
- Traffic Flow: Live traffic flow and metrics
- Configuration Validation: Istio configuration verification
- Security Policies: mTLS and authorization policy visualization
# Deploy complete stack with observability
make gke-setup
# Check observability status
make observability-status
# Get dashboard URLs
make observability-urls
# Local access via port forwarding
make port-forward-observability- Grafana: Metrics and monitoring dashboards
- Kibana: Log analysis and visualization
- Jaeger: Distributed tracing interface
- Kiali: Service mesh topology and health
- Prometheus: Raw metrics and query interface
# Start complete development environment
make dev-up
# Access your services
open http://localhost:3000 # Vue 3 Frontend
open http://localhost:8080 # Golang Backend API
open http://localhost:8080/graphql # GraphQL Playground
open http://localhost:3001 # Grafana Dashboards (admin/admin123)
open http://localhost:16686 # Jaeger Tracing UI
open http://localhost:5601 # Kibana Log Analysis- Multi-stage builds with optimized production images
- Security hardening with non-root users and minimal attack surface
- Complete dependency management with all observability libraries
- Health checks and proper signal handling
- Development and production variants with appropriate optimizations
# Project Setup
make setup # Install all dependencies
make install-tools # Verify required tools
make verify-setup # Validate project configuration
# Development Environment
make dev-up # Start full stack with observability
make dev-status # Check service health
make dev-logs # View aggregated logs
make dev-restart # Restart all services
make dev-clean # Clean restart with fresh data
# Docker Operations
make build-images # Build optimized Docker images
make docker-setup # Comprehensive Docker setup
make test-images # Validate built images
# Kubernetes Deployment
make kind-setup # Create local Kubernetes cluster
make kind-deploy # Deploy to Kind with Helm
make gke-setup # Provision GKE infrastructure
make gke-deploy # Deploy to production
# Observability Management
make observability-status # Check observability stack health
make observability-urls # Get dashboard URLs
make port-forward-observability # Local access to dashboards- Terraform Infrastructure: Complete GCP setup with VPC, subnets, and security
- Multi-zone Deployment: High availability across availability zones
- Auto-scaling: Horizontal Pod Autoscaler and Cluster Autoscaler
- Load Balancing: Global load balancer with SSL termination
- Cloud SQL: Managed PostgreSQL with automated backups
- Service Mesh Security: Automatic mTLS between all services
- Network Policies: Micro-segmentation and traffic isolation
- RBAC: Role-based access control for Kubernetes resources
- Pod Security Standards: Security contexts and privilege restrictions
- Secrets Management: Kubernetes secrets and Google Secret Manager
- SLI/SLO Monitoring: Service level indicators and objectives
- Custom Dashboards: Business metrics and KPI tracking
- Intelligent Alerting: Context-aware alerts with proper routing
- Performance Monitoring: Application and infrastructure metrics
- Cost Monitoring: Resource usage and cost optimization
# Application Metrics
- http_requests_total # Request rate by endpoint
- http_request_duration_seconds # Response time percentiles
- db_connections_active # Database connection pool
- users_total # Business metric: user count
- api_calls_total # API usage by type
# Infrastructure Metrics
- container_cpu_usage_seconds_total
- container_memory_usage_bytes
- node_filesystem_avail_bytes
- kubernetes_pod_restart_total- OpenTelemetry Integration: Modern instrumentation framework
- End-to-end Tracing: Complete request flow across services
- Performance Analysis: Identify bottlenecks and optimize latency
- Error Tracking: Trace-level error investigation and debugging
- Service Dependencies: Visualize service interaction patterns
- Structured Logging: JSON format with consistent fields
- Log Aggregation: Centralized collection from all services
- Real-time Processing: Stream processing with Fluent Bit
- Advanced Search: Elasticsearch-powered log search and filtering
- Log Visualization: Interactive dashboards and analytics
- Traffic Management: Intelligent routing and load balancing
- Security Policies: mTLS, authentication, and authorization
- Observability: Automatic metrics, logs, and traces
- Resilience: Circuit breakers, retries, and fault injection
- Configuration Management: Declarative traffic and security policies
- Automated Testing: Unit tests, integration tests, and security scans
- Multi-environment Deployment: Staging and production pipelines
- Container Security: Vulnerability scanning with Trivy
- Infrastructure Validation: Terraform plan and apply automation
- Rollback Capabilities: Automated rollback on deployment failures
- Hot Reloading: Frontend and backend development with live reload
- API Documentation: GraphQL playground and REST API docs
- Database Migrations: Automated schema management
- Code Quality: Linting, formatting, and pre-commit hooks
- Debugging: Distributed tracing and structured logging
- Health Checks: Comprehensive health monitoring at all levels
- Graceful Shutdowns: Proper signal handling and connection draining
- Resource Management: CPU/memory limits and requests optimization
- Backup & Recovery: Automated database backups and disaster recovery
- Performance Tuning: Application and infrastructure optimization
After completing this tutorial, you'll master:
- Vue 3 with Composition API and TypeScript
- Golang backend development with modern practices
- GraphQL and REST API design and implementation
- Database design and optimization techniques
- Docker containerization and multi-stage builds
- Kubernetes orchestration and resource management
- Helm package management and templating
- Service mesh architecture and implementation
- Infrastructure as Code with Terraform
- CI/CD pipeline design and implementation
- Container security and best practices
- Cloud platform management (GCP)
- Metrics collection and visualization
- Distributed tracing and performance analysis
- Centralized logging and log analysis
- Service mesh observability and security
- High availability and disaster recovery
- Auto-scaling and performance optimization
- Security hardening and compliance
- Monitoring, alerting, and incident response
- Prerequisites Check:
make install-tools - Project Setup:
make setup - Start Development:
make dev-up - Explore Dashboards: Visit the observability URLs
- Deploy to Kubernetes:
make kind-setup && make kind-deploy - Production Deployment: Configure GCP and run
make gke-setup
Comprehensive guides available in the docs/ directory:
- Detailed setup instructions for each component
- Best practices and troubleshooting guides
- Architecture decisions and design patterns
- Production deployment and operations guides
This tutorial is designed to be educational and extensible. Areas for enhancement:
- Additional cloud providers (AWS, Azure)
- More frontend frameworks (React, Angular)
- Advanced security features (OPA, Falco)
- GitOps workflows (ArgoCD, Flux)
- Service mesh alternatives (Linkerd, Consul Connect)
🎯 This tutorial provides a complete, production-ready foundation for modern cloud-native application development with enterprise-grade observability and operations.