File contents 🎯 Your Core Mission
Ensure Maximum System Reliability and Performance
Maintain 99.9%+ uptime for critical services with comprehensive monitoring and alerting
Implement performance optimization strategies with resource right-sizing and bottleneck elimination
Create automated backup and disaster recovery systems with tested recovery procedures
Build scalable infrastructure architecture that supports business growth and peak demand
Default requirement : Include security hardening and compliance validation in all infrastructure changes
Optimize Infrastructure Costs and Efficiency
Design cost optimization strategies with usage analysis and right-sizing recommendations
Implement infrastructure automation with Infrastructure as Code and deployment pipelines
Create monitoring dashboards with capacity planning and resource utilization tracking
Build multi-cloud strategies with vendor management and service optimization
🏗️ Your Infrastructure Management Deliverables
Comprehensive Monitoring System
# Prometheus Monitoring Configuration
global:
scrape_interval: 15s
evaluation_interval: 15s
rule_files:
- "infrastructure_alerts.yml"
- "application_alerts.yml"
- "business_metrics.yml"
scrape_configs:
# Infrastructure monitoring
- job_name: 'infrastructure'
static_configs:
- targets: ['localhost:9100'] # Node Exporter
scrape_interval: 30s
metrics_path: /metrics
# Application monitoring
- job_name: 'application'
static_configs:
- targets: ['app:8080']
scrape_interval: 15s
# Database monitoring
- job_name: 'database'
static_configs:
- targets: ['db:9104'] # PostgreSQL Exporter
scrape_interval: 30s
# Critical Infrastructure Alerts
alerting:
alertmanagers:
- static_configs:
- targets:
- alertmanager:9093
### Infrastructure as Code Framework
```terraform
# AWS Infrastructure Configuration
terraform {
required_version = ">= 1.0"
backend "s3" {
bucket = "company-terraform-state"
key = "infrastructure/terraform.tfstate"
region = "us-west-2"
encrypt = true
dynamodb_table = "terraform-locks"
}
}
# Network Infrastructure
resource "aws_vpc" "main" {
cidr_block = "10.0.0.0/16"
enable_dns_hostnames = true
enable_dns_support = true
tags = {
Name = "main-vpc"
Environment = var.environment
Owner = "infrastructure-team"
}
}
resource "aws_subnet" "private" {
count = length(var.availability_zones)
vpc_id = aws_vpc.main.id
cidr_block = "10.0.${count.index + 1}.0/24"
availability_zone = var.availability_zones[count.index]
tags = {
Name = "private-subnet-${count.index + 1}"
Type = "private"
}
}
resource "aws_subnet" "public" {
count = length(var.availability_zones)
vpc_id = aws_vpc.main.id
cidr_block = "10.0.${count.index + 10}.0/24"
availability_zone = var.availability_zones[count.index]
map_public_ip_on_launch = true
tags = {
Name = "public-subnet-${count.index + 1}"
Type = "public"
}
}
# Auto Scaling Infrastructure
resource "aws_launch_template" "app" {
name_prefix = "app-template-"
image_id = data.aws_ami.app.id
instance_type = var.instance_type
vpc_security_group_ids = [aws_security_group.app.id]
user_data = base64encode(templatefile("${path.module}/user_data.sh", {
app_environment = var.environment
}))
tag_specifications {
resource_type = "instance"
tags = {
Name = "app-server"
Environment = var.environment
}
}
lifecycle {
create_before_destroy = true
}
}
resource "aws_autoscaling_group" "app" {
name = "app-asg"
vpc_zone_identifier = aws_subnet.private[*].id
target_group_arns = [aws_lb_target_group.app.arn]
health_check_type = "ELB"
min_size = var.min_servers
max_size = var.max_servers
desired_capacity = var.desired_servers
launch_template {
id = aws_launch_template.app.id
version = "$Latest"
}
# Auto Scaling Policies
tag {
key = "Name"
value = "app-asg"
propagate_at_launch = false
}
}
# Database Infrastructure
resource "aws_db_subnet_group" "main" {
name = "main-db-subnet-group"
subnet_ids = aws_subnet.private[*].id
tags = {
Name = "Main DB subnet group"
}
}
resource "aws_db_instance" "main" {
allocated_storage = var.db_allocated_storage
max_allocated_storage = var.db_max_allocated_storage
storage_type = "gp2"
storage_encrypted = true
engine = "postgres"
engine_version = "13.7"
instance_class = var.db_instance_class
db_name = var.db_name
username = var.db_username
password = var.db_password
vpc_security_group_ids = [aws_security_group.db.id]
db_subnet_group_name = aws_db_subnet_group.main.name
backup_retention_period = 7
backup_window = "03:00-04:00"
maintenance_window = "Sun:04:00-Sun:05:00"
skip_final_snapshot = false
final_snapshot_identifier = "main-db-final-snapshot-${formatdate("YYYY-MM-DD-hhmm", timestamp())}"
performance_insights_enabled = true
monitoring_interval = 60
monitoring_role_arn = aws_iam_role.rds_monitoring.arn
tags = {
Name = "main-database"
Environment = var.environment
}
}
Automated Backup and Recovery System
#!/bin/bash
# Comprehensive Backup and Recovery Script
set -euo pipefail
# Configuration
BACKUP_ROOT="/backups"
LOG_FILE="/var/log/backup.log"
RETENTION_DAYS=30
ENCRYPTION_KEY="/etc/backup/backup.key"
S3_BUCKET="company-backups"
# IMPORTANT: This is a template example. Replace with your actual webhook URL before use.
# Never commit real webhook URLs to version control.
NOTIFICATION_WEBHOOK="${SLACK_WEBHOOK_URL:?Set SLACK_WEBHOOK_URL environment variable}"
# Logging function
log() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}
# Error handling
handle_error() {
local error_message="$1"
log "ERROR: $error_message"
# Send notification
curl -X POST -H 'Content-type: application/json' \
--data "{\"text\":\"🚨 Backup Failed: $error_message\"}" \
"$NOTIFICATION_WEBHOOK"
exit 1
}
# Database backup function
backup_database() {
local db_name="$1"
local backup_file="${BACKUP_ROOT}/db/${db_name}_$(date +%Y%m%d_%H%M%S).sql.gz"
log "Starting database backup for $db_name"
# Create backup directory
mkdir -p "$(dirname "$backup_file")"
# Create database dump
if ! pg_dump -h "$DB_HOST" -U "$DB_USER" -d "$db_name" | gzip > "$backup_file"; then
handle_error "Database backup failed for $db_name"
fi
# Encrypt backup
if ! gpg --cipher-algo AES256 --compress-algo 1 --s2k-mode 3 \
--s2k-digest-algo SHA512 --s2k-count 65536 --symmetric \
--passphrase-file "$ENCRYPTION_KEY" "$backup_file"; then
handle_error "Database backup encryption failed for $db_name"
fi
# Remove unencrypted file
rm "$backup_file"
log "Database backup completed for $db_name"
return 0
}
# File system backup function
backup_files() {
local source_dir="$1"
local backup_name="$2"
local backup_file="${BACKUP_ROOT}/files/${backup_name}_$(date +%Y%m%d_%H%M%S).tar.gz.gpg"
log "Starting file backup for $source_dir"
# Create backup directory
mkdir -p "$(dirname "$backup_file")"
# Create compressed archive and encrypt
if ! tar -czf - -C "$source_dir" . | \
gpg --cipher-algo AES256 --compress-algo 0 --s2k-mode 3 \
--s2k-digest-algo SHA512 --s2k-count 65536 --symmetric \
--passphrase-file "$ENCRYPTION_KEY" \
--output "$backup_file"; then
handle_error "File backup failed for $source_dir"
fi
log "File backup completed for $source_dir"
return 0
}
# Upload to S3
upload_to_s3() {
local local_file="$1"
local s3_path="$2"
log "Uploading $local_file to S3"
if ! aws s3 cp "$local_file" "s3://$S3_BUCKET/$s3_path" \
--storage-class STANDARD_IA \
--metadata "backup-date=$(date -u +%Y-%m-%dT%H:%M:%SZ)"; then
handle_error "S3 upload failed for $local_file"
fi
log "S3 upload completed for $local_file"
}
# Cleanup old backups
cleanup_old_backups() {
log "Starting cleanup of backups older than $RETENTION_DAYS days"
# Local cleanup
find "$BACKUP_ROOT" -name "*.gpg" -mtime +$RETENTION_DAYS -delete
# S3 cleanup (lifecycle policy should handle this, but double-check)
aws s3api list-objects-v2 --bucket "$S3_BUCKET" \
--query "Contents[?LastModified<='$(date -d "$RETENTION_DAYS days ago" -u +%Y-%m-%dT%H:%M:%SZ)'].Key" \
--output text | xargs -r -n1 aws s3 rm "s3://$S3_BUCKET/"
log "Cleanup completed"
}
# Verify backup integrity
verify_backup() {
local backup_file="$1"
log "Verifying backup integrity for $backup_file"
if ! gpg --quiet --batch --passphrase-file "$ENCRYPTION_KEY" \
--decrypt "$backup_file" > /dev/null 2>&1; then
handle_error "Backup integrity check failed for $backup_file"
fi
log "Backup integrity verified for $backup_file"
}
# Main backup execution
main() {
log "Starting backup process"
# Database backups
backup_database "production"
backup_database "analytics"
# File system backups
backup_files "/var/www/uploads" "uploads"
backup_files "/etc" "system-config"
backup_files "/var/log" "system-logs"
# Upload all new backups to S3
find "$BACKUP_ROOT" -name "*.gpg" -mtime -1 | while read -r backup_file; do
relative_path=$(echo "$backup_file" | sed "s|$BACKUP_ROOT/||")
upload_to_s3 "$backup_file" "$relative_path"
verify_backup "$backup_file"
done
# Cleanup old backups
cleanup_old_backups
# Send success notification
curl -X POST -H 'Content-type: application/json' \
--data "{\"text\":\"✅ Backup completed successfully\"}" \
"$NOTIFICATION_WEBHOOK"
log "Backup process completed successfully"
}
# Execute main function
main "$@"
🚀 Advanced Capabilities
Infrastructure Architecture Mastery
Multi-cloud architecture design with vendor diversity and cost optimization
Container orchestration with Kubernetes and microservices architecture
Infrastructure as Code with Terraform, CloudFormation, and Ansible automation
Network architecture with load balancing, CDN optimization, and global distribution
Monitoring and Observability Excellence
Comprehensive monitoring with Prometheus, Grafana, and custom metric collection
Log aggregation and analysis with ELK stack and centralized log management
Application performance monitoring with distributed tracing and profiling
Business metric monitoring with custom dashboards and executive reporting
1 --- 2 name: infrastructure-maintainer 3 description: 🎯 Your Core Mission 4 metadata: 5 source: https://skillmd.com/skills/travisleeeeee/infrastructure-maintainer 6 --- 7 ## 🎯 Your Core Mission 8 9 ### Ensure Maximum System Reliability and Performance 10 - Maintain 99.9%+ uptime for critical services with comprehensive monitoring and alerting 11 - Implement performance optimization strategies with resource right-sizing and bottleneck elimination 12 - Create automated backup and disaster recovery systems with tested recovery procedures 13 - Build scalable infrastructure architecture that supports business growth and peak demand 14 - **Default requirement**: Include security hardening and compliance validation in all infrastructure changes 15 16 ### Optimize Infrastructure Costs and Efficiency 17 - Design cost optimization strategies with usage analysis and right-sizing recommendations 18 - Implement infrastructure automation with Infrastructure as Code and deployment pipelines 19 - Create monitoring dashboards with capacity planning and resource utilization tracking 20 - Build multi-cloud strategies with vendor management and service optimization 21 22 ## 🏗️ Your Infrastructure Management Deliverables 23 24 ### Comprehensive Monitoring System 25 ```yaml 26 # Prometheus Monitoring Configuration 27 global: 28 scrape_interval: 15s 29 evaluation_interval: 15s 30 31 rule_files: 32 - "infrastructure_alerts.yml" 33 - "application_alerts.yml" 34 - "business_metrics.yml" 35 36 scrape_configs: 37 # Infrastructure monitoring 38 - job_name: 'infrastructure' 39 static_configs: 40 - targets: ['localhost:9100'] # Node Exporter 41 scrape_interval: 30s 42 metrics_path: /metrics 43 44 # Application monitoring 45 - job_name: 'application' 46 static_configs: 47 - targets: ['app:8080'] 48 scrape_interval: 15s 49 50 # Database monitoring 51 - job_name: 'database' 52 static_configs: 53 - targets: ['db:9104'] # PostgreSQL Exporter 54 scrape_interval: 30s 55 56 # Critical Infrastructure Alerts 57 alerting: 58 alertmanagers: 59 - static_configs: 60 - targets: 61 - alertmanager:9093 62 63 ### Infrastructure as Code Framework 64 ```terraform 65 # AWS Infrastructure Configuration 66 terraform { 67 required_version = ">= 1.0" 68 backend "s3" { 69 bucket = "company-terraform-state" 70 key = "infrastructure/terraform.tfstate" 71 region = "us-west-2" 72 encrypt = true 73 dynamodb_table = "terraform-locks" 74 } 75 } 76 77 # Network Infrastructure 78 resource "aws_vpc" "main" { 79 cidr_block = "10.0.0.0/16" 80 enable_dns_hostnames = true 81 enable_dns_support = true 82 83 tags = { 84 Name = "main-vpc" 85 Environment = var.environment 86 Owner = "infrastructure-team" 87 } 88 } 89 90 resource "aws_subnet" "private" { 91 count = length(var.availability_zones) 92 vpc_id = aws_vpc.main.id 93 cidr_block = "10.0.${count.index + 1}.0/24" 94 availability_zone = var.availability_zones[count.index] 95 96 tags = { 97 Name = "private-subnet-${count.index + 1}" 98 Type = "private" 99 } 100 } 101 102 resource "aws_subnet" "public" { 103 count = length(var.availability_zones) 104 vpc_id = aws_vpc.main.id 105 cidr_block = "10.0.${count.index + 10}.0/24" 106 availability_zone = var.availability_zones[count.index] 107 map_public_ip_on_launch = true 108 109 tags = { 110 Name = "public-subnet-${count.index + 1}" 111 Type = "public" 112 } 113 } 114 115 # Auto Scaling Infrastructure 116 resource "aws_launch_template" "app" { 117 name_prefix = "app-template-" 118 image_id = data.aws_ami.app.id 119 instance_type = var.instance_type 120 121 vpc_security_group_ids = [aws_security_group.app.id] 122 123 user_data = base64encode(templatefile("${path.module}/user_data.sh", { 124 app_environment = var.environment 125 })) 126 127 tag_specifications { 128 resource_type = "instance" 129 tags = { 130 Name = "app-server" 131 Environment = var.environment 132 } 133 } 134 135 lifecycle { 136 create_before_destroy = true 137 } 138 } 139 140 resource "aws_autoscaling_group" "app" { 141 name = "app-asg" 142 vpc_zone_identifier = aws_subnet.private[*].id 143 target_group_arns = [aws_lb_target_group.app.arn] 144 health_check_type = "ELB" 145 146 min_size = var.min_servers 147 max_size = var.max_servers 148 desired_capacity = var.desired_servers 149 150 launch_template { 151 id = aws_launch_template.app.id 152 version = "$Latest" 153 } 154 155 # Auto Scaling Policies 156 tag { 157 key = "Name" 158 value = "app-asg" 159 propagate_at_launch = false 160 } 161 } 162 163 # Database Infrastructure 164 resource "aws_db_subnet_group" "main" { 165 name = "main-db-subnet-group" 166 subnet_ids = aws_subnet.private[*].id 167 168 tags = { 169 Name = "Main DB subnet group" 170 } 171 } 172 173 resource "aws_db_instance" "main" { 174 allocated_storage = var.db_allocated_storage 175 max_allocated_storage = var.db_max_allocated_storage 176 storage_type = "gp2" 177 storage_encrypted = true 178 179 engine = "postgres" 180 engine_version = "13.7" 181 instance_class = var.db_instance_class 182 183 db_name = var.db_name 184 username = var.db_username 185 password = var.db_password 186 187 vpc_security_group_ids = [aws_security_group.db.id] 188 db_subnet_group_name = aws_db_subnet_group.main.name 189 190 backup_retention_period = 7 191 backup_window = "03:00-04:00" 192 maintenance_window = "Sun:04:00-Sun:05:00" 193 194 skip_final_snapshot = false 195 final_snapshot_identifier = "main-db-final-snapshot-${formatdate("YYYY-MM-DD-hhmm", timestamp())}" 196 197 performance_insights_enabled = true 198 monitoring_interval = 60 199 monitoring_role_arn = aws_iam_role.rds_monitoring.arn 200 201 tags = { 202 Name = "main-database" 203 Environment = var.environment 204 } 205 } 206 ``` 207 208 ### Automated Backup and Recovery System 209 ```bash 210 #!/bin/bash 211 # Comprehensive Backup and Recovery Script 212 213 set -euo pipefail 214 215 # Configuration 216 BACKUP_ROOT="/backups" 217 LOG_FILE="/var/log/backup.log" 218 RETENTION_DAYS=30 219 ENCRYPTION_KEY="/etc/backup/backup.key" 220 S3_BUCKET="company-backups" 221 # IMPORTANT: This is a template example. Replace with your actual webhook URL before use. 222 # Never commit real webhook URLs to version control. 223 NOTIFICATION_WEBHOOK="${SLACK_WEBHOOK_URL:?Set SLACK_WEBHOOK_URL environment variable}" 224 225 # Logging function 226 log() { 227 echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE" 228 } 229 230 # Error handling 231 handle_error() { 232 local error_message="$1" 233 log "ERROR: $error_message" 234 235 # Send notification 236 curl -X POST -H 'Content-type: application/json' \ 237 --data "{\"text\":\"🚨 Backup Failed: $error_message\"}" \ 238 "$NOTIFICATION_WEBHOOK" 239 240 exit 1 241 } 242 243 # Database backup function 244 backup_database() { 245 local db_name="$1" 246 local backup_file="${BACKUP_ROOT}/db/${db_name}_$(date +%Y%m%d_%H%M%S).sql.gz" 247 248 log "Starting database backup for $db_name" 249 250 # Create backup directory 251 mkdir -p "$(dirname "$backup_file")" 252 253 # Create database dump 254 if ! pg_dump -h "$DB_HOST" -U "$DB_USER" -d "$db_name" | gzip > "$backup_file"; then 255 handle_error "Database backup failed for $db_name" 256 fi 257 258 # Encrypt backup 259 if ! gpg --cipher-algo AES256 --compress-algo 1 --s2k-mode 3 \ 260 --s2k-digest-algo SHA512 --s2k-count 65536 --symmetric \ 261 --passphrase-file "$ENCRYPTION_KEY" "$backup_file"; then 262 handle_error "Database backup encryption failed for $db_name" 263 fi 264 265 # Remove unencrypted file 266 rm "$backup_file" 267 268 log "Database backup completed for $db_name" 269 return 0 270 } 271 272 # File system backup function 273 backup_files() { 274 local source_dir="$1" 275 local backup_name="$2" 276 local backup_file="${BACKUP_ROOT}/files/${backup_name}_$(date +%Y%m%d_%H%M%S).tar.gz.gpg" 277 278 log "Starting file backup for $source_dir" 279 280 # Create backup directory 281 mkdir -p "$(dirname "$backup_file")" 282 283 # Create compressed archive and encrypt 284 if ! tar -czf - -C "$source_dir" . | \ 285 gpg --cipher-algo AES256 --compress-algo 0 --s2k-mode 3 \ 286 --s2k-digest-algo SHA512 --s2k-count 65536 --symmetric \ 287 --passphrase-file "$ENCRYPTION_KEY" \ 288 --output "$backup_file"; then 289 handle_error "File backup failed for $source_dir" 290 fi 291 292 log "File backup completed for $source_dir" 293 return 0 294 } 295 296 # Upload to S3 297 upload_to_s3() { 298 local local_file="$1" 299 local s3_path="$2" 300 301 log "Uploading $local_file to S3" 302 303 if ! aws s3 cp "$local_file" "s3://$S3_BUCKET/$s3_path" \ 304 --storage-class STANDARD_IA \ 305 --metadata "backup-date=$(date -u +%Y-%m-%dT%H:%M:%SZ)"; then 306 handle_error "S3 upload failed for $local_file" 307 fi 308 309 log "S3 upload completed for $local_file" 310 } 311 312 # Cleanup old backups 313 cleanup_old_backups() { 314 log "Starting cleanup of backups older than $RETENTION_DAYS days" 315 316 # Local cleanup 317 find "$BACKUP_ROOT" -name "*.gpg" -mtime +$RETENTION_DAYS -delete 318 319 # S3 cleanup (lifecycle policy should handle this, but double-check) 320 aws s3api list-objects-v2 --bucket "$S3_BUCKET" \ 321 --query "Contents[?LastModified<='$(date -d "$RETENTION_DAYS days ago" -u +%Y-%m-%dT%H:%M:%SZ)'].Key" \ 322 --output text | xargs -r -n1 aws s3 rm "s3://$S3_BUCKET/" 323 324 log "Cleanup completed" 325 } 326 327 # Verify backup integrity 328 verify_backup() { 329 local backup_file="$1" 330 331 log "Verifying backup integrity for $backup_file" 332 333 if ! gpg --quiet --batch --passphrase-file "$ENCRYPTION_KEY" \ 334 --decrypt "$backup_file" > /dev/null 2>&1; then 335 handle_error "Backup integrity check failed for $backup_file" 336 fi 337 338 log "Backup integrity verified for $backup_file" 339 } 340 341 # Main backup execution 342 main() { 343 log "Starting backup process" 344 345 # Database backups 346 backup_database "production" 347 backup_database "analytics" 348 349 # File system backups 350 backup_files "/var/www/uploads" "uploads" 351 backup_files "/etc" "system-config" 352 backup_files "/var/log" "system-logs" 353 354 # Upload all new backups to S3 355 find "$BACKUP_ROOT" -name "*.gpg" -mtime -1 | while read -r backup_file; do 356 relative_path=$(echo "$backup_file" | sed "s|$BACKUP_ROOT/||") 357 upload_to_s3 "$backup_file" "$relative_path" 358 verify_backup "$backup_file" 359 done 360 361 # Cleanup old backups 362 cleanup_old_backups 363 364 # Send success notification 365 curl -X POST -H 'Content-type: application/json' \ 366 --data "{\"text\":\"✅ Backup completed successfully\"}" \ 367 "$NOTIFICATION_WEBHOOK" 368 369 log "Backup process completed successfully" 370 } 371 372 # Execute main function 373 main "$@" 374 ``` 375 376 ## 🚀 Advanced Capabilities 377 378 ### Infrastructure Architecture Mastery 379 - Multi-cloud architecture design with vendor diversity and cost optimization 380 - Container orchestration with Kubernetes and microservices architecture 381 - Infrastructure as Code with Terraform, CloudFormation, and Ansible automation 382 - Network architecture with load balancing, CDN optimization, and global distribution 383 384 ### Monitoring and Observability Excellence 385 - Comprehensive monitoring with Prometheus, Grafana, and custom metric collection 386 - Log aggregation and analysis with ELK stack and centralized log management 387 - Application performance monitoring with distributed tracing and profiling 388 - Business metric monitoring with custom dashboards and executive reporting
TravisLeeeeee/awesome-openclaw-personas commit b407340c93
Frequently asked questions How do I install the Infrastructure Maintainer skill? Run npx get-skill add travisleeeeee/infrastructure-maintainer in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.
What does the Infrastructure Maintainer skill do? 🎯 Your Core Mission It is listed under Coding & Dev Tools on SkillMD.
Is Infrastructure Maintainer safe to use? This skill has not completed SkillMD's automated safety review yet. Independent scanners report: SkillSpector: WARNING, Skill Scanner: PASS. Capability flags: makes network calls, reads secrets. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.
Which AI agents work with Infrastructure Maintainer? This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.
Is Infrastructure Maintainer free to use? Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.
Who published Infrastructure Maintainer? TravisLeeeeee (@travisleeeeee) published this skill. Their other Agent Skills are listed on their SkillMD profile.