jeremylongshore/tons-of-skills-marketplace / plugins/devops/service-mesh-configurator/skills/configuring-service-meshes
configuring-service-meshes
VerifiedConfigure this skill configures service meshes like istio and linkerd for microservices. it generates production-ready configurations, implements best practices, and ensures a security-first approach. use this skill when the user asks to "configure service ... Use when appropriate context detected. Trigger with relevant phrases based on skill purpose.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 4.4 KB |
| assets/README.md | markdown | 496 B |
| assets/error_handling_strategies.md | markdown | 8.4 KB |
| assets/example_microservices_architecture.md | markdown | 5.5 KB |
| assets/istio_config_template.yaml | config | 2.3 KB |
| assets/linkerd_config_template.yaml | config | 3.5 KB |
| references/README.md | markdown | 68 B |
| scripts/README.md | markdown | 506 B |
| scripts/deploy_config.shexecutable | script | 7.6 KB |
| scripts/generate_test_traffic.pyexecutable | script | 14.3 KB |
| scripts/rollback_config.shexecutable | script | 8.2 KB |
| scripts/validate_config.pyexecutable | script | 9.7 KB |
scripts/validate_config.py
View on GitHub#!/usr/bin/env python3
"""
Service mesh configuration validator.
Validates service mesh configuration against best practices including:
- Kubernetes manifest syntax
- Istio/Linkerd resource definitions
- Traffic policies and rules
- Security policies
- Common misconfigurations
"""
import argparse
import json
import sys
from pathlib import Path
from typing import Any, Dict
import yaml
class ServiceMeshValidator:
"""Validates service mesh configurations."""
SUPPORTED_MESHES = ["istio", "linkerd", "consul", "osm"]
ISTIO_RESOURCES = {
"VirtualService",
"DestinationRule",
"Gateway",
"ServiceEntry",
"RequestAuthentication",
"AuthorizationPolicy",
"Sidecar",
"PeerAuthentication",
"Telemetry",
}
LINKERD_RESOURCES = {"TrafficPolicy", "ServiceProfile", "AuthorizationPolicy", "ExternalWorkload", "Server"}
def __init__(self, mesh_type: str = "istio"):
"""
Initialize validator.
Args:
mesh_type: Type of service mesh
"""
if mesh_type not in self.SUPPORTED_MESHES:
raise ValueError(f"Unsupported mesh type: {mesh_type}")
self.mesh_type = mesh_type
self.errors = []
self.warnings = []
self.resources_found = []
def validate_file(self, file_path: str) -> bool:
"""
Validate configuration file.
Args:
file_path: Path to YAML configuration file
Returns:
True if valid, False otherwise
"""
try:
path = Path(file_path)
if not path.exists():
self.errors.append(f"File not found: {file_path}")
return False
if path.suffix.lower() not in [".yaml", ".yml"]:
self.errors.append(f"Expected YAML file, got: {path.suffix}")
return False
with open(file_path, "r") as f:
configs = yaml.safe_load_all(f)
for config in configs:
if config:
self._validate_resource(config)
return len(self.errors) == 0
except yaml.YAMLError as e:
self.errors.append(f"YAML syntax error: {str(e)}")
return False
except Exception as e:
self.errors.append(f"Validation error: {str(e)}")
return False
def _validate_resource(self, resource: Dict[str, Any]) -> None:
"""Validate individual resource."""
# Check required fields
required = ["apiVersion", "kind", "metadata"]
for field in required:
if field not in resource:
self.errors.append(f"Missing required field: {field}")
return
kind = resource.get("kind", "")
metadata = resource.get("metadata", {})
# Check metadata
if "name" not in metadata:
self.errors.append(f"Resource {kind}: missing metadata.name")
# Check namespace (recommended)
if "namespace" not in metadata:
self.warnings.append(f"Resource {kind}: no namespace specified")
# Mesh-specific validation
if self.mesh_type == "istio":
self._validate_istio_resource(resource)
elif self.mesh_type == "linkerd":
self._validate_linkerd_resource(resource)
self.resources_found.append(
{
"kind": kind,
"name": metadata.get("name"),
"namespace": metadata.get("namespace"),
}
)
def _validate_istio_resource(self, resource: Dict[str, Any]) -> None:
"""Validate Istio-specific resource."""
kind = resource.get("kind", "")
if kind == "VirtualService":
self._validate_virtual_service(resource)
elif kind == "DestinationRule":
self._validate_destination_rule(resource)
elif kind == "Gateway":
self._validate_gateway(resource)
elif kind == "AuthorizationPolicy":
self._validate_auth_policy(resource)
def _validate_virtual_service(self, resource: Dict[str, Any]) -> None:
"""Validate VirtualService resource."""
spec = resource.get("spec", {})
# Check hosts
if "hosts" not in spec:
self.errors.append("VirtualService: missing spec.hosts")
# Check http routes
http_routes = spec.get("http", [])
if not http_routes and not spec.get("tcp", []) and not spec.get("tls", []):
self.warnings.append("VirtualService: no routes defined")
for idx, route in enumerate(http_routes):
if "route" not in route:
self.errors.append(f"VirtualService http[{idx}]: missing route")
def _validate_destination_rule(self, resource: Dict[str, Any]) -> None:
"""Validate DestinationRule resource."""
spec = resource.get("spec", {})
# Check host
if "host" not in spec:
self.errors.append("DestinationRule: missing spec.host")
# Check for security settings
if "trafficPolicy" not in spec:
self.warnings.append("DestinationRule: no traffic policy specified")
def _validate_gateway(self, resource: Dict[str, Any]) -> None:
"""Validate Gateway resource."""
spec = resource.get("spec", {})
# Check selector
if "selector" not in spec:
self.errors.append("Gateway: missing spec.selector")
# Check servers
servers = spec.get("servers", [])
if not servers:
self.errors.append("Gateway: no servers defined")
for idx, server in enumerate(servers):
if "port" not in server:
self.errors.append(f"Gateway server[{idx}]: missing port")
if "hosts" not in server:
self.errors.append(f"Gateway server[{idx}]: missing hosts")
def _validate_auth_policy(self, resource: Dict[str, Any]) -> None:
"""Validate AuthorizationPolicy resource."""
spec = resource.get("spec", {})
# Check for at least one rule or default action
if not spec.get("rules", []) and "action" not in spec:
self.warnings.append("AuthorizationPolicy: no rules or action defined")
def _validate_linkerd_resource(self, resource: Dict[str, Any]) -> None:
"""Validate Linkerd-specific resource."""
kind = resource.get("kind", "")
if kind == "TrafficPolicy":
self._validate_traffic_policy(resource)
elif kind == "AuthorizationPolicy":
self._validate_linkerd_auth_policy(resource)
def _validate_traffic_policy(self, resource: Dict[str, Any]) -> None:
"""Validate TrafficPolicy resource."""
spec = resource.get("spec", {})
if "targetRef" not in spec:
self.errors.append("TrafficPolicy: missing spec.targetRef")
def _validate_linkerd_auth_policy(self, resource: Dict[str, Any]) -> None:
"""Validate Linkerd AuthorizationPolicy resource."""
spec = resource.get("spec", {})
if "targetRef" not in spec:
self.errors.append("AuthorizationPolicy: missing spec.targetRef")
def check_best_practices(self) -> None:
"""Check against best practices."""
if self.mesh_type == "istio":
# Check for sidecar injection
has_sidecar = any(r["kind"] == "Sidecar" for r in self.resources_found)
if not has_sidecar:
self.warnings.append("Best practice: Consider explicitly defining Sidecar resources")
# Check for PeerAuthentication
has_peer_auth = any(r["kind"] == "PeerAuthentication" for r in self.resources_found)
if not has_peer_auth:
self.warnings.append("Security: Consider defining PeerAuthentication for mTLS")
def get_report(self) -> Dict[str, Any]:
"""Get validation report."""
return {
"valid": len(self.errors) == 0,
"mesh_type": self.mesh_type,
"resources_found": self.resources_found,
"errors": self.errors,
"warnings": self.warnings,
"error_count": len(self.errors),
"warning_count": len(self.warnings),
"resource_count": len(self.resources_found),
}
def main():
"""Main entry point."""
parser = argparse.ArgumentParser(description="Validate service mesh configuration against best practices")
parser.add_argument("config_file", help="Path to service mesh configuration file (YAML)")
parser.add_argument(
"-m", "--mesh", choices=["istio", "linkerd", "consul", "osm"], default="istio", help="Type of service mesh"
)
parser.add_argument("-o", "--output", help="Save validation report to JSON file")
parser.add_argument("-v", "--verbose", action="store_true", help="Print detailed validation report")
parser.add_argument("--strict", action="store_true", help="Treat warnings as errors")
args = parser.parse_args()
try:
validator = ServiceMeshValidator(mesh_type=args.mesh)
is_valid = validator.validate_file(args.config_file)
validator.check_best_practices()
report = validator.get_report()
# Check strict mode
if args.strict and report["warning_count"] > 0:
is_valid = False
# Output report
if args.verbose or not is_valid:
print(json.dumps(report, indent=2))
# Save report if requested
if args.output:
with open(args.output, "w") as f:
json.dump(report, f, indent=2)
print(f"Validation report saved to: {args.output}")
sys.exit(0 if is_valid else 1)
except Exception as e:
print(f"Error: {str(e)}", file=sys.stderr)
sys.exit(1)
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |