[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6HAT55ATNAGF3346K4AC9PC":3,"skill-same:01M6HAT55ATNAGF3346K4AC9PC":60},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":30,"linkOnly":31,"markdownContent":32,"markdownBody":33,"frontMatter":34,"refName":38,"commitSha":39,"skillDirectory":40,"forksCount":14,"repositoryHtmlUrl":41,"repositoryHomepageUrl":6,"ownerHtmlUrl":42,"ownerBlogUrl":43,"ownerDescription":44,"updatedAt":45,"install":46,"resources":59},"01M6HAT55ATNAGF3346K4AC9PC","high-availability",null,"High availability architecture and implementation for fault-tolerant distributed systems","NeuralBlitz\u002FMito","NeuralBlitz","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F79354388?v=4","01M6H8T2TFH477HRS0KTSTKR2E","David Riggs","01M6H8T2YQQDXPYM092P670Z21",0,"MIT","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fsystems-administration\u002Fhigh-availability\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27,28,29],"high availability","availability","high","architecture","distributed","opencode","implementation","distributed systems","systems","administration","for","2026-11-10 10:12:30",false,"---\nname: high-availability\ndescription: High availability architecture and implementation for fault-tolerant distributed systems\nlicense: MIT\ncompatibility: opencode\nmetadata:\n  audience: architects\n  category: systems-administration\n---\n\n## What I do\n- Design high availability architectures\n- Implement load balancing strategies\n- Configure failover clustering\n- Set up database replication\n- Design multi-region deployments\n- Implement circuit breakers\n- Create health checks and redundancy\n- Configure session and state management\n- Design for horizontal scaling\n- Implement chaos engineering\n\n## When to use me\nWhen designing fault-tolerant systems, implementing high availability infrastructure, or architecting for uptime requirements.\n\n## Core Concepts\n- Active-active and active-passive configurations\n- Load balancing algorithms and strategies\n- Failover mechanisms and detection\n- Database replication (master-slave, multi-master)\n- Consensus algorithms (Raft, Paxos)\n- Circuit breaker patterns\n- Service mesh architectures\n- DNS-based failover\n- CDN and edge caching\n- Disaster recovery vs high availability\n\n## Code Examples\n\n### Load Balancer Configuration\n```nginx\n# Nginx HA configuration\nupstream backend {\n    least_conn;\n    \n    server 10.0.1.10:8080 max_fails=3 fail_timeout=30s;\n    server 10.0.1.11:8080 max_fails=3 fail_timeout=30s;\n    server 10.0.1.12:8080 max_fails=3 fail_timeout=30s backup;\n    \n    keepalive 32;\n}\n\nserver {\n    listen 443 ssl http2;\n    server_name app.example.com;\n    \n    ssl_certificate \u002Fetc\u002Fssl\u002Fcerts\u002Fapp.crt;\n    ssl_certificate_key \u002Fetc\u002Fssl\u002Fprivate\u002Fapp.key;\n    ssl_protocols TLSv1.2 TLSv1.3;\n    \n    # Health check endpoint\n    location \u002Fhealth {\n        proxy_pass http:\u002F\u002Fbackend;\n        proxy_connect_timeout 5s;\n        proxy_read_timeout 10s;\n        health_check interval=5 passes=2 fails=3;\n    }\n    \n    location \u002F {\n        proxy_pass http:\u002F\u002Fbackend;\n        proxy_http_version 1.1;\n        proxy_set_header Connection \"\";\n        proxy_set_header Host $host;\n        proxy_set_header X-Real-IP $remote_addr;\n        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n        proxy_set_header X-Forwarded-Proto $scheme;\n        \n        # Circuit breaker\n        proxy_next_upstream error timeout http_503 http_504;\n        proxy_connect_timeout 10s;\n        proxy_send_timeout 60s;\n        proxy_read_timeout 60s;\n    }\n    \n    # Rate limiting\n    limit_req_zone $binary_remote_addr zone=api:10m rate=100r\u002Fs;\n    \n    location \u002Fapi\u002F {\n        limit_req zone=api burst=20 nodelay;\n        proxy_pass http:\u002F\u002Fbackend;\n    }\n}\n```\n\n```haproxy\n# haproxy.cfg\nglobal\n    log 127.0.0.1 local0\n    maxconn 4096\n    daemon\n    tune.ssl.default-dh-param 2048\n\ndefaults\n    log global\n    mode http\n    option httplog\n    option dontlognull\n    timeout connect 5000ms\n    timeout client 50000ms\n    timeout server 50000ms\n    retries 3\n\nfrontend http-in\n    bind *:80\n    bind *:443 ssl crt \u002Fetc\u002Fssl\u002Fcerts\u002F\n    \n    acl is-health-check src 10.0.0.0\u002F8\n    use_backend health if is-health-check\n    \n    default_backend app-servers\n\nbackend app-servers\n    balance roundrobin\n    option httpchk GET \u002Fhealth\n    http-check expect status 200\n    \n    server app1 10.0.1.10:8080 check inter 5s rise 2 fall 3\n    server app2 10.0.1.11:8080 check inter 5s rise 2 fall 3\n    server app3 10.0.1.12:8080 check inter 5s rise 2 fall 3 backup\n    \n    # Stickiness\n    stick-table type ip size 200k expire 30m\n    stick on src\n    \n    # Circuit breaker\n    http-request track-sc0 src\n    acl conn_fail sc1_conn_fail gt 3\n    acl mark_remove sc1_marked_remove lt 1\n    http-request silent-drop if conn_fail mark_remove\n\nbackend health\n    server health1 10.0.0.1:9090 check\n```\n\n### Database HA Configuration\n```yaml\n# PostgreSQL Patroni configuration\nrestapi:\n  listen: 0.0.0.0:8008\n  connect_address: 10.0.1.10:8008\n  authentication:\n    username: admin\n    password: ${PATRONI_PASSWORD}\n\netcd:\n  host: 10.0.1.20:2379\n  protocols: http\n  cacert: \u002Fetc\u002Fssl\u002Fcerts\u002Fca.crt\n  key: \u002Fetc\u002Fssl\u002Fprivate\u002Fpatroni.key\n  cert: \u002Fetc\u002Fssl\u002Fcerts\u002Fpatroni.crt\n\nbootstrap:\n  dcs:\n    ttl: 30\n    loop_wait: 10\n    retry_timeout: 10\n    maximum_lag_on_failover: 1048576\n    master_start_timeout: 300\n    synchronous_mode: false\n\n  pg_hba:\n    - host replication replicator 10.0.1.0\u002F24 md5\n    - host all all 0.0.0.0\u002F0 md5\n\npostgresql:\n  listen: 0.0.0.0:5432\n  connect_address: 10.0.1.10:5432\n  authentication:\n    replication:\n      username: replication\n      password: ${REPLICATION_PASSWORD}\n    superuser:\n      username: postgres\n      password: ${SUPERUSER_PASSWORD}\n  parameters:\n    max_connections: 200\n    shared_buffers: 4GB\n    work_mem: 64MB\n    maintenance_work_mem: 1GB\n    effective_cache_size: 12GB\n    synchronous_commit: on\n    synchronous_standby_names: '*'\n  pg_rewind:\n    username: postgres\n    password: ${SUPERUSER_PASSWORD}\n```\n\n### Circuit Breaker Implementation\n```python\nimport asyncio\nfrom enum import Enum\nfrom dataclasses import dataclass\nfrom typing import Callable, Any\nimport time\n\nclass CircuitState(Enum):\n    CLOSED = \"closed\"\n    OPEN = \"open\"\n    HALF_OPEN = \"half_open\"\n\n@dataclass\nclass CircuitBreakerConfig:\n    failure_threshold: int = 5\n    success_threshold: int = 2\n    timeout_seconds: float = 60.0\n    sampling_window: int = 60\n\nclass CircuitBreaker:\n    def __init__(self, name: str, config: CircuitBreakerConfig = None):\n        self.name = name\n        self.config = config or CircuitBreakerConfig()\n        self.state = CircuitState.CLOSED\n        self.failures = 0\n        self.successes = 0\n        self.last_failure_time = 0\n        self._lock = asyncio.Lock()\n    \n    async def call(self, func: Callable, *args, **kwargs) -> Any:\n        async with self._lock:\n            if self._should_open():\n                self.state = CircuitState.OPEN\n                self.last_failure_time = time.time()\n            \n            if self.state == CircuitState.OPEN:\n                if self._timeout_elapsed():\n                    self.state = CircuitState.HALF_OPEN\n                else:\n                    raise CircuitOpenError(f\"Circuit breaker {self.name} is open\")\n        \n        return await self._execute(func, *args, **kwargs)\n    \n    async def _execute(self, func: Callable, *args, **kwargs) -> Any:\n        try:\n            result = await func(*args, **kwargs)\n            await self._on_success()\n            return result\n        except Exception as e:\n            await self._on_failure()\n            raise\n    \n    async def _on_success(self):\n        async with self._lock:\n            if self.state == CircuitState.HALF_OPEN:\n                self.successes += 1\n                if self.successes >= self.config.success_threshold:\n                    self.state = CircuitState.CLOSED\n                    self.failures = 0\n                    self.successes = 0\n    \n    async def _on_failure(self):\n        async with self._lock:\n            self.failures += 1\n            if self.state == CircuitState.HALF_OPEN:\n                self.state = CircuitState.OPEN\n                self.last_failure_time = time.time()\n                self.successes = 0\n    \n    def _should_open(self) -> bool:\n        return (self.state == CircuitState.HALF_OPEN and \n                self.failures >= self.config.failure_threshold)\n    \n    def _timeout_elapsed(self) -> bool:\n        return time.time() - self.last_failure_time > self.config.timeout_seconds\n\n# Usage\ncircuit = CircuitBreaker(\"database\", CircuitBreakerConfig(\n    failure_threshold=3,\n    timeout_seconds=30\n))\n\nasync def get_user(user_id: int):\n    async with circuit:\n        return await database.query(\"SELECT * FROM users WHERE id = ?\", user_id)\n```\n\n### Health Check Aggregation\n```python\nfrom typing import Dict, List\nfrom dataclasses import dataclass\nfrom enum import Enum\nimport asyncio\n\nclass HealthStatus(Enum):\n    HEALTHY = \"healthy\"\n    DEGRADED = \"degraded\"\n    UNHEALTHY = \"unhealthy\"\n\n@dataclass\nclass ComponentHealth:\n    name: str\n    status: HealthStatus\n    latency_ms: float\n    message: str\n    details: dict = None\n\nclass HealthChecker:\n    def __init__(self):\n        self.checks = {}\n    \n    def register_check(self, name: str, check_func: callable):\n        self.checks[name] = check_func\n    \n    async def check_all(self) -> Dict[str, ComponentHealth]:\n        results = {}\n        tasks = []\n        \n        for name, check_func in self.checks.items():\n            tasks.append(self._run_check(name, check_func))\n        \n        for result in await asyncio.gather(*tasks, return_exceptions=True):\n            if isinstance(result, Exception):\n                results[\"unknown\"] = ComponentHealth(\n                    name=\"unknown\",\n                    status=HealthStatus.UNHEALTHY,\n                    latency_ms=0,\n                    message=str(result)\n                )\n            else:\n                results[result.name] = result\n        \n        return results\n    \n    async def _run_check(self, name: str, check_func: callable) -> ComponentHealth:\n        start = time.time()\n        try:\n            if asyncio.iscoroutinefunction(check_func):\n                result = await check_func()\n            else:\n                result = check_func()\n            \n            latency_ms = (time.time() - start) * 1000\n            \n            return ComponentHealth(\n                name=name,\n                status=HealthStatus.HEALTHY if result else HealthStatus.DEGRADED,\n                latency_ms=latency_ms,\n                message=\"Check passed\" if result else \"Check returned unhealthy\"\n            )\n        except Exception as e:\n            return ComponentHealth(\n                name=name,\n                status=HealthStatus.UNHEALTHY,\n                latency_ms=(time.time() - start) * 1000,\n                message=str(e)\n            )\n    \n    def aggregate_status(self, healths: Dict[str, ComponentHealth]) -> HealthStatus:\n        statuses = [h.status for h in healths.values()]\n        \n        if any(s == HealthStatus.UNHEALTHY for s in statuses):\n            return HealthStatus.UNHEALTHY\n        elif any(s == HealthStatus.DEGRADED for s in statuses):\n            return HealthStatus.DEGRADED\n        return HealthStatus.HEALTHY\n\n# Usage\nchecker = HealthChecker()\nchecker.register_check(\"database\", lambda: db.health_check())\nchecker.register_check(\"redis\", lambda: redis.ping())\nchecker.register_check(\"external_api\", external_api.health_check)\n\nasync def health_endpoint():\n    healths = await checker.check_all()\n    status = checker.aggregate_status(healths)\n    return {\"status\": status.value, \"components\": healths}\n```\n\n## Best Practices\n- Design for failure - assume components will fail\n- Use active-active for true high availability\n- Implement proper health checks at multiple levels\n- Keep configurations version-controlled\n- Test failover procedures regularly\n- Monitor SLIs and SLOs actively\n- Use circuit breakers to prevent cascade failures\n- Maintain proper capacity buffers\n- Document failure modes and runbooks\n- Consider geographic redundancy for disaster recovery\n","## What I do\n- Design high availability architectures\n- Implement load balancing strategies\n- Configure failover clustering\n- Set up database replication\n- Design multi-region deployments\n- Implement circuit breakers\n- Create health checks and redundancy\n- Configure session and state management\n- Design for horizontal scaling\n- Implement chaos engineering\n\n## When to use me\nWhen designing fault-tolerant systems, implementing high availability infrastructure, or architecting for uptime requirements.\n\n## Core Concepts\n- Active-active and active-passive configurations\n- Load balancing algorithms and strategies\n- Failover mechanisms and detection\n- Database replication (master-slave, multi-master)\n- Consensus algorithms (Raft, Paxos)\n- Circuit breaker patterns\n- Service mesh architectures\n- DNS-based failover\n- CDN and edge caching\n- Disaster recovery vs high availability\n\n## Code Examples\n\n### Load Balancer Configuration\n```nginx\n# Nginx HA configuration\nupstream backend {\n    least_conn;\n    \n    server 10.0.1.10:8080 max_fails=3 fail_timeout=30s;\n    server 10.0.1.11:8080 max_fails=3 fail_timeout=30s;\n    server 10.0.1.12:8080 max_fails=3 fail_timeout=30s backup;\n    \n    keepalive 32;\n}\n\nserver {\n    listen 443 ssl http2;\n    server_name app.example.com;\n    \n    ssl_certificate \u002Fetc\u002Fssl\u002Fcerts\u002Fapp.crt;\n    ssl_certificate_key \u002Fetc\u002Fssl\u002Fprivate\u002Fapp.key;\n    ssl_protocols TLSv1.2 TLSv1.3;\n    \n    # Health check endpoint\n    location \u002Fhealth {\n        proxy_pass http:\u002F\u002Fbackend;\n        proxy_connect_timeout 5s;\n        proxy_read_timeout 10s;\n        health_check interval=5 passes=2 fails=3;\n    }\n    \n    location \u002F {\n        proxy_pass http:\u002F\u002Fbackend;\n        proxy_http_version 1.1;\n        proxy_set_header Connection \"\";\n        proxy_set_header Host $host;\n        proxy_set_header X-Real-IP $remote_addr;\n        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n        proxy_set_header X-Forwarded-Proto $scheme;\n        \n        # Circuit breaker\n        proxy_next_upstream error timeout http_503 http_504;\n        proxy_connect_timeout 10s;\n        proxy_send_timeout 60s;\n        proxy_read_timeout 60s;\n    }\n    \n    # Rate limiting\n    limit_req_zone $binary_remote_addr zone=api:10m rate=100r\u002Fs;\n    \n    location \u002Fapi\u002F {\n        limit_req zone=api burst=20 nodelay;\n        proxy_pass http:\u002F\u002Fbackend;\n    }\n}\n```\n\n```haproxy\n# haproxy.cfg\nglobal\n    log 127.0.0.1 local0\n    maxconn 4096\n    daemon\n    tune.ssl.default-dh-param 2048\n\ndefaults\n    log global\n    mode http\n    option httplog\n    option dontlognull\n    timeout connect 5000ms\n    timeout client 50000ms\n    timeout server 50000ms\n    retries 3\n\nfrontend http-in\n    bind *:80\n    bind *:443 ssl crt \u002Fetc\u002Fssl\u002Fcerts\u002F\n    \n    acl is-health-check src 10.0.0.0\u002F8\n    use_backend health if is-health-check\n    \n    default_backend app-servers\n\nbackend app-servers\n    balance roundrobin\n    option httpchk GET \u002Fhealth\n    http-check expect status 200\n    \n    server app1 10.0.1.10:8080 check inter 5s rise 2 fall 3\n    server app2 10.0.1.11:8080 check inter 5s rise 2 fall 3\n    server app3 10.0.1.12:8080 check inter 5s rise 2 fall 3 backup\n    \n    # Stickiness\n    stick-table type ip size 200k expire 30m\n    stick on src\n    \n    # Circuit breaker\n    http-request track-sc0 src\n    acl conn_fail sc1_conn_fail gt 3\n    acl mark_remove sc1_marked_remove lt 1\n    http-request silent-drop if conn_fail mark_remove\n\nbackend health\n    server health1 10.0.0.1:9090 check\n```\n\n### Database HA Configuration\n```yaml\n# PostgreSQL Patroni configuration\nrestapi:\n  listen: 0.0.0.0:8008\n  connect_address: 10.0.1.10:8008\n  authentication:\n    username: admin\n    password: ${PATRONI_PASSWORD}\n\netcd:\n  host: 10.0.1.20:2379\n  protocols: http\n  cacert: \u002Fetc\u002Fssl\u002Fcerts\u002Fca.crt\n  key: \u002Fetc\u002Fssl\u002Fprivate\u002Fpatroni.key\n  cert: \u002Fetc\u002Fssl\u002Fcerts\u002Fpatroni.crt\n\nbootstrap:\n  dcs:\n    ttl: 30\n    loop_wait: 10\n    retry_timeout: 10\n    maximum_lag_on_failover: 1048576\n    master_start_timeout: 300\n    synchronous_mode: false\n\n  pg_hba:\n    - host replication replicator 10.0.1.0\u002F24 md5\n    - host all all 0.0.0.0\u002F0 md5\n\npostgresql:\n  listen: 0.0.0.0:5432\n  connect_address: 10.0.1.10:5432\n  authentication:\n    replication:\n      username: replication\n      password: ${REPLICATION_PASSWORD}\n    superuser:\n      username: postgres\n      password: ${SUPERUSER_PASSWORD}\n  parameters:\n    max_connections: 200\n    shared_buffers: 4GB\n    work_mem: 64MB\n    maintenance_work_mem: 1GB\n    effective_cache_size: 12GB\n    synchronous_commit: on\n    synchronous_standby_names: '*'\n  pg_rewind:\n    username: postgres\n    password: ${SUPERUSER_PASSWORD}\n```\n\n### Circuit Breaker Implementation\n```python\nimport asyncio\nfrom enum import Enum\nfrom dataclasses import dataclass\nfrom typing import Callable, Any\nimport time\n\nclass CircuitState(Enum):\n    CLOSED = \"closed\"\n    OPEN = \"open\"\n    HALF_OPEN = \"half_open\"\n\n@dataclass\nclass CircuitBreakerConfig:\n    failure_threshold: int = 5\n    success_threshold: int = 2\n    timeout_seconds: float = 60.0\n    sampling_window: int = 60\n\nclass CircuitBreaker:\n    def __init__(self, name: str, config: CircuitBreakerConfig = None):\n        self.name = name\n        self.config = config or CircuitBreakerConfig()\n        self.state = CircuitState.CLOSED\n        self.failures = 0\n        self.successes = 0\n        self.last_failure_time = 0\n        self._lock = asyncio.Lock()\n    \n    async def call(self, func: Callable, *args, **kwargs) -> Any:\n        async with self._lock:\n            if self._should_open():\n                self.state = CircuitState.OPEN\n                self.last_failure_time = time.time()\n            \n            if self.state == CircuitState.OPEN:\n                if self._timeout_elapsed():\n                    self.state = CircuitState.HALF_OPEN\n                else:\n                    raise CircuitOpenError(f\"Circuit breaker {self.name} is open\")\n        \n        return await self._execute(func, *args, **kwargs)\n    \n    async def _execute(self, func: Callable, *args, **kwargs) -> Any:\n        try:\n            result = await func(*args, **kwargs)\n            await self._on_success()\n            return result\n        except Exception as e:\n            await self._on_failure()\n            raise\n    \n    async def _on_success(self):\n        async with self._lock:\n            if self.state == CircuitState.HALF_OPEN:\n                self.successes += 1\n                if self.successes >= self.config.success_threshold:\n                    self.state = CircuitState.CLOSED\n                    self.failures = 0\n                    self.successes = 0\n    \n    async def _on_failure(self):\n        async with self._lock:\n            self.failures += 1\n            if self.state == CircuitState.HALF_OPEN:\n                self.state = CircuitState.OPEN\n                self.last_failure_time = time.time()\n                self.successes = 0\n    \n    def _should_open(self) -> bool:\n        return (self.state == CircuitState.HALF_OPEN and \n                self.failures >= self.config.failure_threshold)\n    \n    def _timeout_elapsed(self) -> bool:\n        return time.time() - self.last_failure_time > self.config.timeout_seconds\n\n# Usage\ncircuit = CircuitBreaker(\"database\", CircuitBreakerConfig(\n    failure_threshold=3,\n    timeout_seconds=30\n))\n\nasync def get_user(user_id: int):\n    async with circuit:\n        return await database.query(\"SELECT * FROM users WHERE id = ?\", user_id)\n```\n\n### Health Check Aggregation\n```python\nfrom typing import Dict, List\nfrom dataclasses import dataclass\nfrom enum import Enum\nimport asyncio\n\nclass HealthStatus(Enum):\n    HEALTHY = \"healthy\"\n    DEGRADED = \"degraded\"\n    UNHEALTHY = \"unhealthy\"\n\n@dataclass\nclass ComponentHealth:\n    name: str\n    status: HealthStatus\n    latency_ms: float\n    message: str\n    details: dict = None\n\nclass HealthChecker:\n    def __init__(self):\n        self.checks = {}\n    \n    def register_check(self, name: str, check_func: callable):\n        self.checks[name] = check_func\n    \n    async def check_all(self) -> Dict[str, ComponentHealth]:\n        results = {}\n        tasks = []\n        \n        for name, check_func in self.checks.items():\n            tasks.append(self._run_check(name, check_func))\n        \n        for result in await asyncio.gather(*tasks, return_exceptions=True):\n            if isinstance(result, Exception):\n                results[\"unknown\"] = ComponentHealth(\n                    name=\"unknown\",\n                    status=HealthStatus.UNHEALTHY,\n                    latency_ms=0,\n                    message=str(result)\n                )\n            else:\n                results[result.name] = result\n        \n        return results\n    \n    async def _run_check(self, name: str, check_func: callable) -> ComponentHealth:\n        start = time.time()\n        try:\n            if asyncio.iscoroutinefunction(check_func):\n                result = await check_func()\n            else:\n                result = check_func()\n            \n            latency_ms = (time.time() - start) * 1000\n            \n            return ComponentHealth(\n                name=name,\n                status=HealthStatus.HEALTHY if result else HealthStatus.DEGRADED,\n                latency_ms=latency_ms,\n                message=\"Check passed\" if result else \"Check returned unhealthy\"\n            )\n        except Exception as e:\n            return ComponentHealth(\n                name=name,\n                status=HealthStatus.UNHEALTHY,\n                latency_ms=(time.time() - start) * 1000,\n                message=str(e)\n            )\n    \n    def aggregate_status(self, healths: Dict[str, ComponentHealth]) -> HealthStatus:\n        statuses = [h.status for h in healths.values()]\n        \n        if any(s == HealthStatus.UNHEALTHY for s in statuses):\n            return HealthStatus.UNHEALTHY\n        elif any(s == HealthStatus.DEGRADED for s in statuses):\n            return HealthStatus.DEGRADED\n        return HealthStatus.HEALTHY\n\n# Usage\nchecker = HealthChecker()\nchecker.register_check(\"database\", lambda: db.health_check())\nchecker.register_check(\"redis\", lambda: redis.ping())\nchecker.register_check(\"external_api\", external_api.health_check)\n\nasync def health_endpoint():\n    healths = await checker.check_all()\n    status = checker.aggregate_status(healths)\n    return {\"status\": status.value, \"components\": healths}\n```\n\n## Best Practices\n- Design for failure - assume components will fail\n- Use active-active for true high availability\n- Implement proper health checks at multiple levels\n- Keep configurations version-controlled\n- Test failover procedures regularly\n- Monitor SLIs and SLOs actively\n- Use circuit breakers to prevent cascade failures\n- Maintain proper capacity buffers\n- Document failure modes and runbooks\n- Consider geographic redundancy for disaster recovery\n",{"name":5,"license":15,"metadata":35,"description":7,"compatibility":24},{"audience":36,"category":37},"architects","systems-administration","main","2ea764e153842704d24a2e9aa4170441a7f03081",".opencode\u002Fskills\u002Fsystems-administration\u002Fhigh-availability","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito","https:\u002F\u002Fgithub.com\u002FNeuralBlitz","nuralnexus.org","Theoretical and Futuristic AI Nerd 🤓 ","2026-11-12 03:13:05",{"source":8,"skillName":5,"commands":47,"prompt":57,"zipAvailable":58},[48,51,54],{"tool":49,"command":50},"npx","npx skills add NeuralBlitz\u002FMito --skill high-availability",{"tool":52,"command":53},"bunx","bunx skills add NeuralBlitz\u002FMito --skill high-availability",{"tool":55,"command":56},"pnpm","pnpm dlx skills add NeuralBlitz\u002FMito --skill high-availability","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fsystems-administration\u002Fhigh-availability\u002FSKILL.md",true,[],[61,76,88,101,109,134],{"skillNo":62,"name":63,"nameZh":6,"description":64,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":65,"categories":66,"keywords":67,"publishedAt":30},"01M6HAZSAQK1S27CEZYAYJTQDX","wireless-communications","Wireless systems, mobile networks, and 5G\u002F6G","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fwireless-communications\u002FSKILL.md",[],[68,69,70,27,71,72,73,74,24,75],"communications","wireless communications","wireless","engineering","networks","5G","students","mobile",{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":30},"01M6HAZFX6E8NK3WZWDX5YCKYY","websockets","WebSocket implementation and best practices","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fwebassembly\u002Fwebsockets\u002FSKILL.md",[],[78,83,84,25,24,85,86,87],"websocket implementation","time","real-time","websocket","best practices",{"skillNo":89,"name":90,"nameZh":6,"description":91,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":92,"categories":93,"keywords":94,"publishedAt":30},"01M6HAZ6DAXBQ7QHXXM1EM7715","vulnerability-auditing","Vulnerability assessment and auditing","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvulnerability-auditing\u002FSKILL.md",[],[95,96,97,98,24,99,100],"vulnerability","vulnerability auditing","security","vulnerability assessment","cybersecurity","assessment",{"skillNo":102,"name":103,"nameZh":6,"description":104,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":105,"categories":106,"keywords":107,"publishedAt":30},"01M6HAZ3FKF3CS9Z3J96RVE2ZE","vulnerability-assessment","Finding and assessing security vulnerabilities","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvue\u002Fvulnerability-assessment\u002FSKILL.md",[],[98,95,100,97,108,24],"vulnerabilities",{"skillNo":110,"name":111,"nameZh":6,"description":112,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":113,"categories":114,"keywords":125,"publishedAt":30},"01M6HAYSHM6HKRKEHFP0SGZQX7","vlsi-design","Very-Large-Scale Integration circuit design and semiconductor engineering","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvlsi-design\u002FSKILL.md",[115,120],{"categoryNo":116,"categoryName":117,"taxonomyType":118,"taxonomyTypeDesc":119},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":121,"categoryName":122,"taxonomyType":123,"taxonomyTypeDesc":124},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[126,127,128,129,130,71,131,24,132,74,133],"vlsi design","VLSI","design","hardware","integration","computer","scale","circuit",{"skillNo":135,"name":136,"nameZh":6,"description":137,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":138,"categories":139,"keywords":140,"publishedAt":30},"01M6HAYPQ30FFE2JXD7WQJ8R6C","unsupervised","Unsupervised learning concepts","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvisualization\u002Funsupervised\u002FSKILL.md",[],[136,141,24,142,143,144,145,146],"learning","intelligence","unsupervised learning","machine","concepts","machine-learning"]