This document outlines the detailed plan and configurations for deploying your microservices onto a Kubernetes cluster. It covers the generation of core Kubernetes manifests, Helm charts for packaging, service mesh integration for advanced traffic management and security, scaling policies for optimal resource utilization, and robust monitoring and logging configurations.
Our goal is to provide a structured, automated, and resilient deployment strategy that ensures high availability, scalability, and operational visibility for your applications.
We will generate the fundamental Kubernetes YAML manifests required for each microservice. These manifests define how your applications run, communicate, and are exposed within the cluster.
Defines the desired state for your application's pods, including the container image, replicas, resource requests/limits, and update strategy.
Key Configurations:
apiVersion: apps/v1kind: Deploymentmetadata.name: Unique identifier for the deployment (e.g., my-service-deployment)spec.replicas: Number of desired pod instances (e.g., 3 for high availability)spec.selector.matchLabels: Labels used to identify pods managed by this deployment.spec.template.metadata.labels: Labels applied to the pods (must match selector).spec.template.spec.containers: * name: Container name (e.g., my-service-container)
* image: Docker image to deploy (e.g., your-registry/my-service:v1.0.0)
* ports: Container ports exposed (e.g., containerPort: 8080)
* env: Environment variables for configuration (e.g., database connection strings, API keys)
* resources: CPU and memory requests (guaranteed) and limits (maximum allowed).
* Example: requests: { cpu: "100m", memory: "128Mi" }, limits: { cpu: "500m", memory: "512Mi" }
* livenessProbe: Health check to detect if the application is running but unhealthy and needs a restart.
* Example: httpGet: { path: /health, port: 8080 }
* readinessProbe: Health check to determine if the application is ready to serve traffic.
* Example: httpGet: { path: /ready, port: 8080 }
spec.strategy: Rolling update strategy for zero-downtime deployments. * Example: type: RollingUpdate, rollingUpdate: { maxSurge: 25%, maxUnavailable: 25% }
Defines a logical set of Pods and a policy by which to access them.
Key Configurations:
apiVersion: v1kind: Servicemetadata.name: Name of the service (e.g., my-service)spec.selector: Labels that match the pods this service should route traffic to.spec.ports: * port: Port on which the service is exposed within the cluster.
* targetPort: Port on the pod that the service forwards traffic to (e.g., 8080).
* protocol: TCP/UDP.
spec.type: * ClusterIP: Default, exposes the service on an internal IP in the cluster (internal only).
* NodePort: Exposes the service on each Node's IP at a static port (external access via node IP:NodePort).
* LoadBalancer: Exposes the service externally using a cloud provider's load balancer.
* ExternalName: Maps the service to the contents of the externalName field (CNAME-like).
Manages external access to services in a cluster, typically HTTP/S. Ingress provides load balancing, SSL termination, and name-based virtual hosting.
Key Configurations:
apiVersion: networking.k8s.io/v1kind: Ingressmetadata.name: Name of the Ingress resource (e.g., my-service-ingress)spec.rules: * host: Domain name (e.g., api.example.com)
* http.paths:
path: URL path (e.g., /my-service(/.)?)
* pathType: Prefix or Exact
* backend.service.name: Name of the Kubernetes Service to route traffic to.
* backend.service.port.number: Port of the Kubernetes Service.
spec.tls: SSL/TLS termination configuration. * hosts: List of hosts for which TLS is configured.
* secretName: Kubernetes Secret containing the TLS certificate and key.
For managing configuration data and sensitive information separately from application code.
Helm is the package manager for Kubernetes. Helm charts define, install, and upgrade even the most complex Kubernetes applications. We will create Helm charts for each microservice or logical group of services.
values.yaml files, enabling easy environment-specific deployments (dev, staging, prod).A Helm chart is a directory containing:
Chart.yaml: Information about the chart (name, version, description).values.yaml: Default configuration values for the chart.templates/: Directory containing Kubernetes manifest templates (.yaml files) that are rendered using the values.charts/: Optional directory for subcharts (dependencies).values.yaml Structure* **`Gateway`**: Configures a load balancer for HTTP/TCP traffic entering the mesh from outside.
* **`PeerAuthentication`**: Defines mTLS policies (e.g., `PERMISSIVE` or `STRICT`).
* **`AuthorizationPolicy`**: Defines access control rules for services within the mesh.
---
### 4. Scaling Policies
Automated scaling ensures that your applications can handle varying loads efficiently, optimizing resource usage and maintaining performance.
#### 4.1. Horizontal Pod Autoscaler (HPA)
Automatically scales the number of pods in a deployment based on observed CPU utilization or other select metrics.
**Key Configurations:**
* **`apiVersion`**: `autoscaling/v2`
* **`kind`**: `HorizontalPodAutoscaler`
* **`metadata.name`**: Name of the HPA (e.g., `my-service-hpa`)
* **`spec.scaleTargetRef`**:
* **`apiVersion`**: `apps/v1`
* **`kind`**: `Deployment` (or `StatefulSet`)
* **`name`**: Name of the deployment to scale (e.g., `my-service-deployment`)
* **`spec.minReplicas`**: Minimum number of pods (e.g., `2`)
* **`spec.maxReplicas`**: Maximum number of pods (e.g., `10`)
* **`spec.metrics`**: Defines the metrics to use for scaling.
* **Resource Metrics (CPU, Memory)**:
This document outlines a comprehensive marketing strategy for the "Kubernetes Deployment Planner" workflow, designed to drive adoption, establish market leadership, and achieve measurable business objectives. This strategy encompasses target audience analysis, recommended marketing channels, a robust messaging framework, and key performance indicators (KPIs) for success.
Understanding our prospective users is paramount to crafting effective marketing messages and selecting appropriate channels. Our primary and secondary target audiences are defined by their roles, pain points, and desired outcomes.
* Profile: Highly technical individuals responsible for the reliability, scalability, and performance of applications in production. They manage CI/CD pipelines, Kubernetes clusters, and cloud infrastructure.
* Pain Points:
* Manual creation and maintenance of complex Kubernetes YAML manifests (Deployments, Services, Ingress, ConfigMaps, Secrets, etc.) is time-consuming and error-prone.
* Lack of standardization across microservices leads to "configuration drift" and increased debugging time.
* Difficulty in implementing and managing advanced Kubernetes features like service meshes (Istio, Linkerd) and robust autoscaling policies (HPA, VPA, KEDA).
* Onboarding new team members to existing complex Kubernetes deployment patterns.
* Ensuring security best practices are consistently applied across all deployments.
* Goals: Automate repetitive tasks, ensure consistency, improve reliability, reduce operational overhead, accelerate deployment cycles, adopt GitOps principles.
* Profile: Responsible for designing, implementing, and maintaining the Kubernetes infrastructure. They set standards, define best practices, and evaluate tools.
* Pain Points:
* Enforcing organizational standards and best practices across multiple development teams.
* Managing the complexity of multi-cluster or multi-cloud deployments.
* Ensuring cost efficiency through optimized resource allocation and scaling.
* Auditing and compliance for Kubernetes configurations.
* Goals: Achieve standardization, enhance security posture, optimize resource utilization, simplify cluster management, enable self-service for developers within guardrails.
* Profile: Individuals focused on writing application code, often interacting with Kubernetes for deploying their services.
* Pain Points:
* Steep learning curve for Kubernetes concepts and YAML syntax.
* Distraction from core development tasks due to deployment complexities.
* Slow feedback loops due to manual deployment processes.
* Goals: Focus on coding, faster deployment of their applications, simplified interaction with the underlying infrastructure.
* Profile: Decision-makers responsible for team productivity, project delivery, budget, and overall technology strategy.
* Pain Points:
* Slow time-to-market due to inefficient deployment processes.
* High operational costs associated with manual configuration and debugging.
* Difficulty in scaling development teams and maintaining consistency.
* Concerns about reliability, security, and compliance.
* Goals: Improve team productivity, accelerate time-to-market, reduce operational costs, enhance system reliability and security, foster innovation.
To effectively reach our target audiences, a multi-channel approach leveraging both digital and community-based strategies is recommended.
* Blog Posts: In-depth tutorials ("How to Generate Helm Charts for Microservices"), best practices ("5 Ways to Standardize K8s Deployments"), thought leadership ("The Future of GitOps with Automated Manifest Generation"), and problem/solution articles.
* Whitepapers/E-books: Comprehensive guides on specific topics like "Advanced Kubernetes Scaling Strategies" or "Implementing Service Meshes with Automated Configuration."
* Webinars/Live Demos: Showcase the planner's capabilities, provide step-by-step guides, and host Q&A sessions. Partner with industry experts for co-hosted webinars.
* Video Tutorials: Short, engaging videos demonstrating specific features and use cases (e.g., "Generate a Production-Ready K8s Deployment in 5 Minutes"). Publish on YouTube and embedded on the website.
* Case Studies: Highlight successful implementations with quantifiable benefits (e.g., "Reduced Deployment Time by 70% for Company X").
* Keyword Strategy: Target high-intent keywords such as "Kubernetes deployment automation," "Helm chart generator," "K8s manifest creation tool," "service mesh configuration," "DevOps deployment planner," "Kubernetes scaling policies."
* Technical SEO: Ensure website is fast, mobile-friendly, and technically sound for optimal search engine crawling and indexing.
* Target specific keywords related to Kubernetes deployment challenges and solutions.
* Create compelling ad copy highlighting key benefits (automation, standardization, reliability).
* Utilize remarketing campaigns to re-engage visitors who showed interest.
* LinkedIn: Share thought leadership, blog posts, company news, and engage in relevant groups (e.g., "Kubernetes Community," "DevOps & SRE").
* Twitter: Share quick tips, industry news, interact with influencers, and promote new content. Use relevant hashtags (#Kubernetes, #DevOps, #CloudNative, #SRE).
* Reddit: Participate in subreddits like r/kubernetes, r/devops, r/cloudnative. Share valuable insights and subtly introduce the solution where appropriate, focusing on community value.
* Nurture Sequences: Onboard new subscribers, provide educational content, and guide them through the sales funnel.
* Product Updates: Announce new features, integrations, and improvements.
* Promotional Campaigns: Offer trials, discounts, or exclusive content.
* KubeCon, DevOpsDays: Exhibit, sponsor, and aim for speaking slots to present on topics related to automated Kubernetes deployments.
* Local Kubernetes/DevOps Meetups: Host or sponsor local events, provide food/drinks, and offer short presentations or demos.
* Cloud Providers (AWS, Azure, GCP): Explore marketplace listings and co-marketing opportunities.
* CI/CD Tool Vendors (Jenkins, GitLab, GitHub Actions): Highlight integrations and joint solutions.
* Service Mesh Providers (Istio, Linkerd): Emphasize seamless integration and enhanced capabilities.
Our messaging will be tailored to resonate with the specific pain points and aspirations of our target audience, emphasizing the core value proposition of the Kubernetes Deployment Planner.
"Streamline and standardize your Kubernetes deployments with intelligent automation, ensuring consistency, reliability, and accelerated delivery across all your microservices."
Message:* "Eliminate manual YAML creation and reduce deployment time by automatically generating production-ready manifests, Helm charts, and configurations based on your specifications."
Focus:* Time savings, reduced human error, faster time-to-market.
Message:* "Enforce best practices and organizational standards across all your microservices, preventing configuration drift and ensuring consistent, reliable deployments every time."
Focus:* Reliability, maintainability, reduced debugging, easier onboarding.
Message:* "Generate robust configurations for service meshes (Istio, Linkerd) and intelligent scaling policies (HPA, VPA, KEDA) to build highly available and resilient applications."
Focus:* Uptime, performance, fault tolerance.
Message:* "Free your developers from Kubernetes boilerplate. Let them focus on writing code while the Deployment Planner handles the complexities of infrastructure configuration."
Focus:* Innovation, faster feature development, job satisfaction.
Message:* "Optimize resource utilization with finely tuned scaling policies and efficient manifest generation, leading to significant cost savings on your cloud infrastructure."
Focus:* Reduced cloud spend, better ROI.
Message:* "Integrate security best practices directly into your deployment manifests from the start, ensuring compliance and a stronger security posture."
Focus:* Risk reduction, regulatory adherence.
Measuring the success of our marketing efforts is crucial for continuous optimization. The following KPIs will be tracked across different stages of the marketing and sales funnel.
* Total visitors, unique visitors, traffic sources (organic, paid, referral, direct).
* Bounce rate, average session duration.
* Number of mentions on social media, industry forums, news outlets.
* Share of Voice compared to competitors.
* Number of times ads or content are displayed (PPC, social media).
* Position for target keywords in search engine results.
* Blog post views, time on page, social shares.
* Whitepaper/E-book downloads.
* Webinar registrations and attendance rates.
* Video views and completion rates.
* Likes, comments, shares, retweets.
* Follower growth rate.
* Open rates, click-through rates (CTR).
* Unsubscribe rates.
* Number of forum posts, replies, and upvotes related to our brand or solution.
* Number of Marketing Qualified Leads (MQLs) and Sales Qualified Leads (SQLs) generated.
* Lead source attribution.
* Website visitor to lead conversion rate.
* Lead to demo request conversion rate.
* Trial sign-up conversion rate.
* Efficiency of lead generation efforts across different channels.
* Number of scheduled and completed product demonstrations.
* Total marketing and sales spend divided by the number of new customers.
* Time from initial contact to closed-won deal.
* Total estimated value of active sales opportunities.
* Number of new paying customers.
* Increase in subscription revenue or license sales.
* Monthly/Weekly/Daily Active Users (MAU/WAU/DAU) of the planner.
* Usage of specific features (e.g., Helm chart generation, service mesh config, scaling policies).
* Number of deployments generated or managed per user/organization.
* Percentage of customers who discontinue their subscription.
This comprehensive marketing strategy provides a robust framework for launching and growing the Kubernetes Deployment Planner. Regular review and adaptation of this strategy based on market feedback and KPI performance will be essential for sustained success.
yaml
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70 # Scale when average CPU utilization exceeds 70%
- type: Resource
resource:
name: memory
target:
type: AverageValue
averageValue: 500Mi # Scale
This document provides a detailed and professional output for the "Kubernetes Deployment Planner" workflow, specifically focusing on generating the necessary Kubernetes deployment manifests, Helm charts, service mesh configurations, scaling policies, and monitoring setups for your microservices. This deliverable aims to equip your team with a robust, scalable, and observable foundation for deploying applications on Kubernetes.
This deliverable outlines the core components required for a modern microservice deployment on Kubernetes. It covers:
The provided examples are generic and serve as a template. Specific values (e.g., image names, resource requests, ports, domain names) must be customized for each microservice.
These manifests define the core resources for deploying your microservices. Each microservice will typically require a Deployment, a Service, and potentially an Ingress or Gateway API resource.
deployment.yaml)Defines the desired state for your application's pods, including the container image, replicas, resource requests/limits, and health probes.
apiVersion: apps/v1
kind: Deployment
metadata:
name: [MICROSERVICE-NAME]-deployment
labels:
app: [MICROSERVICE-NAME]
tier: backend # or frontend, worker, etc.
spec:
replicas: 3 # Recommended starting point, adjust based on load
selector:
matchLabels:
app: [MICROSERVICE-NAME]
template:
metadata:
labels:
app: [MICROSERVICE-NAME]
tier: backend
spec:
serviceAccountName: [MICROSERVICE-NAME]-sa # Optional: If specific RBAC is needed
containers:
- name: [MICROSERVICE-NAME]
image: your-registry/[MICROSERVICE-NAME]:[VERSION] # IMPORTANT: Replace with your actual image
ports:
- containerPort: 8080 # IMPORTANT: Replace with your application's listening port
name: http
env:
- name: DATABASE_HOST
value: "database-service.default.svc.cluster.local" # Example env var
- name: API_KEY
valueFrom:
secretKeyRef:
name: [MICROSERVICE-NAME]-secrets # Name of your Kubernetes Secret
key: api-key # Key within the secret
resources:
requests:
cpu: "250m" # Request 0.25 CPU core
memory: "512Mi" # Request 512 MB memory
limits:
cpu: "500m" # Limit to 0.5 CPU core
memory: "1Gi" # Limit to 1 GB memory
livenessProbe: # Checks if the application is running
httpGet:
path: /health # IMPORTANT: Replace with your application's health endpoint
port: http
initialDelaySeconds: 15
periodSeconds: 10
timeoutSeconds: 5
failureThreshold: 3
readinessProbe: # Checks if the application is ready to serve traffic
httpGet:
path: /ready # IMPORTANT: Replace with your application's readiness endpoint
port: http
initialDelaySeconds: 5
periodSeconds: 5
timeoutSeconds: 3
failureThreshold: 2
imagePullSecrets: # If your registry requires authentication
- name: regcred # Name of the secret containing Docker registry credentials
affinity: # Example: Anti-affinity to spread pods across nodes
podAntiAffinity:
preferredDuringSchedulingIgnolredDuringExecution:
- weight: 100
podAffinityTerm:
labelSelector:
matchLabels:
app: [MICROSERVICE-NAME]
topologyKey: "kubernetes.io/hostname" # Spreads pods across different nodes
service.yaml)Creates a stable network endpoint for your microservice, allowing other services or external traffic to reach it.
apiVersion: v1
kind: Service
metadata:
name: [MICROSERVICE-NAME]-service
labels:
app: [MICROSERVICE-NAME]
spec:
selector:
app: [MICROSERVICE-NAME]
ports:
- protocol: TCP
port: 80 # Service port (internal cluster communication)
targetPort: http # Refers to the 'name' of the containerPort in deployment
name: http-service # Name for the port, useful for service mesh
type: ClusterIP # Default, internal-only service. Use LoadBalancer for external access (cloud provider specific)
ingress.yaml or gateway.yaml)Exposes your microservice to external traffic using a domain name, often with TLS termination.
Using Ingress (Standard Kubernetes API):
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: [MICROSERVICE-NAME]-ingress
annotations:
kubernetes.io/ingress.class: nginx # Or gce, traefik, etc., depending on your Ingress Controller
cert-manager.io/cluster-issuer: letsencrypt-prod # If using cert-manager for TLS
nginx.ingress.kubernetes.io/rewrite-target: /$1 # Example for NGINX Ingress
spec:
tls: # Enable TLS
- hosts:
- [MICROSERVICE-NAME].yourdomain.com # IMPORTANT: Replace with your domain
secretName: [MICROSERVICE-NAME]-tls # Secret where TLS certificate will be stored
rules:
- host: [MICROSERVICE-NAME].yourdomain.com # IMPORTANT: Replace with your domain
http:
paths:
- path: /(.*) # Example path, adjust as needed
pathType: Prefix
backend:
service:
name: [MICROSERVICE-NAME]-service
port:
name: http-service # Refers to the name of the service port
Using Gateway API (Newer, more flexible standard, requires controller support):
apiVersion: gateway.networking.k8s.io/v1beta1
kind: HTTPRoute
metadata:
name: [MICROSERVICE-NAME]-route
labels:
app: [MICROSERVICE-NAME]
spec:
parentRefs:
- name: external-http-gateway # Reference to your Gateway resource
namespace: istio-system # Or wherever your Gateway is deployed
hostnames:
- "[MICROSERVICE-NAME].yourdomain.com" # IMPORTANT: Replace with your domain
rules:
- matches:
- path:
type: PathPrefix
value: /
backendRefs:
- name: [MICROSERVICE-NAME]-service
port: 80
Helm simplifies the deployment and management of Kubernetes applications. A Helm chart packages all the necessary Kubernetes manifests, allowing for versioning, templating, and easy installation/upgrades.
A typical Helm chart for a microservice would have the following structure:
[MICROSERVICE-NAME]-chart/
├── Chart.yaml # A YAML file containing information about the chart
├── values.yaml # The default configuration values for this chart
├── templates/ # Directory of templates that will be rendered
│ ├── deployment.yaml
│ ├── service.yaml
│ ├── ingress.yaml
│ ├── hpa.yaml
│ ├── serviceaccount.yaml
│ └── _helpers.tpl # Helper template file
└── README.md
Chart.yaml
apiVersion: v2
name: [MICROSERVICE-NAME]
description: A Helm chart for the [MICROSERVICE-NAME] microservice
version: 0.1.0 # Chart version
appVersion: "1.0.0" # Application version
keywords:
- [MICROSERVICE-NAME]
- microservice
- kubernetes
home: https://your-repo-link.com/[MICROSERVICE-NAME]
sources:
- https://github.com/your-org/your-repo
maintainers:
- name: Your Name
email: you@yourdomain.com
values.yamlThis file centralizes configurable parameters for your manifests.
replicaCount: 3
image:
repository: your-registry/[MICROSERVICE-NAME]
pullPolicy: IfNotPresent
# Overrides the image tag whose default is the chart appVersion.
tag: "1.0.0"
service:
type: ClusterIP
port: 80
targetPort: 8080
name: http-service
ingress:
enabled: true
className: "nginx"
annotations:
cert-manager.io/cluster-issuer: letsencrypt-prod
hosts:
- host: [MICROSERVICE-NAME].yourdomain.com
paths:
- path: /
pathType: Prefix
tls:
- secretName: [MICROSERVICE-NAME]-tls
hosts:
- [MICROSERVICE-NAME].yourdomain.com
resources:
requests:
cpu: 250m
memory: 512Mi
limits:
cpu: 500m
memory: 1Gi
env:
DATABASE_HOST: "database-service.default.svc.cluster.local"
secrets:
apiKey: "your-default-api-key" # DO NOT store sensitive data here for production
# Horizontal Pod Autoscaler
autoscaling:
enabled: true
minReplicas: 2
maxReplicas: 10
targetCPUUtilizationPercentage: 80
targetMemoryUtilizationPercentage: 75 # Optional
Your Kubernetes manifests within templates/ will use Go templating to inject values from values.yaml.
Example templates/deployment.yaml snippet:
# ... (metadata, selector, etc.)
spec:
replicas: {{ .Values.replicaCount }}
template:
# ...
spec:
containers:
- name: {{ .Chart.Name }}
image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
ports:
- containerPort: {{ .Values.service.targetPort }}
name: {{ .Values.service.name }}
env:
{{- range $key, $value := .Values.env }}
- name: {{ $key }}
value: {{ $value | quote }}
{{- end }}
- name: API_KEY
valueFrom:
secretKeyRef:
name: {{ include "[MICROSERVICE-NAME].fullname" . }}-secrets # Using a helper for secret name
key: api-key
resources:
{{- toYaml .Values.resources | nindent 12 }}
# ... (probes, affinity, etc.)
helm package [MICROSERVICE-NAME]-charthelm install [RELEASE-NAME] [MICROSERVICE-NAME]-chart-[VERSION].tgz -n [NAMESPACE]helm upgrade [RELEASE-NAME] [MICROSERVICE-NAME]-chart-[VERSION].tgz -n [NAMESPACE] helm install [RELEASE-NAME] [MICROSERVICE-NAME]-chart --set image.tag=1.0.1 --set replicaCount=5 -n [NAMESPACE]
or using a custom values.yaml:
helm install [RELEASE-NAME] [MICROSERVICE-NAME]-chart -f my-custom-values.yaml -n [NAMESPACE]
A service mesh provides advanced capabilities for traffic management, security, and observability without modifying application code. Istio is a popular choice.
Assuming Istio is already installed in your cluster (e.g., in istio-system namespace).
4.2.1. Gateway (gateway.yaml) - For Ingress (if not using Ingress/Gateway API directly)
This defines the entry point for external traffic into the mesh.
apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
name: [MICROSERVICE-NAME]-gateway
namespace: default # Or the namespace where your service resides
spec:
selector:
istio: ingressgateway # Selects the default Istio Ingress Gateway
servers:
- port:
number: 80
name: http
protocol: HTTP
hosts:
- "[MICROSERVICE-NAME].yourdomain.com"
- port:
number: 443
name: https
protocol: HTTPS
tls:
mode: SIMPLE
credentialName: [MICROSERVICE-NAME]-tls # Kubernetes secret with TLS cert/key
hosts:
- "[MICROSERVICE-NAME].yourdomain.com"
4.2.2. Virtual Service (virtualservice.yaml) - Traffic Routing
Routes traffic from the Gateway (or other services) to your microservice.
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
name: [MICROSERVICE-NAME]-vs
namespace: default
spec:
hosts:
- "[MICROSERVICE-NAME].yourdomain.com" # For external access
- "[MICROSERVICE-NAME]-service.default.svc.cluster.local" # For internal access
gateways:
- [MICROSERVICE-NAME]-gateway # Attach to your gateway for external traffic
- mesh # Apply to all sidecars in the mesh for internal traffic
http:
- match:
- uri:
prefix: /api/v1/[