{"id":29874691,"url":"https://github.com/christian-deleon/tailscale-coredns","last_synced_at":"2026-04-15T16:09:05.572Z","repository":{"id":304578297,"uuid":"1019153744","full_name":"christian-deleon/tailscale-coredns","owner":"christian-deleon","description":"Tailscale-integrated CoreDNS plugin that resolves hostnames to Tailscale IPs with subdomain tags and split DNS management.","archived":false,"fork":false,"pushed_at":"2025-11-05T16:38:03.000Z","size":118,"stargazers_count":0,"open_issues_count":7,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-11-05T18:25:41.568Z","etag":null,"topics":["coredns","coredns-plugin","dns-server","tailscale","tailscale-server","tailscaled"],"latest_commit_sha":null,"homepage":"","language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/christian-deleon.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-07-13T21:22:34.000Z","updated_at":"2025-07-28T22:28:18.000Z","dependencies_parsed_at":"2025-07-14T02:53:45.910Z","dependency_job_id":"fa979a1c-9053-4e17-889a-7e358e9f2bcd","html_url":"https://github.com/christian-deleon/tailscale-coredns","commit_stats":null,"previous_names":["christian-deleon/tailscale-coredns"],"tags_count":24,"template":false,"template_full_name":null,"purl":"pkg:github/christian-deleon/tailscale-coredns","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/christian-deleon%2Ftailscale-coredns","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/christian-deleon%2Ftailscale-coredns/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/christian-deleon%2Ftailscale-coredns/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/christian-deleon%2Ftailscale-coredns/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/christian-deleon","download_url":"https://codeload.github.com/christian-deleon/tailscale-coredns/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/christian-deleon%2Ftailscale-coredns/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31848829,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-15T15:24:51.572Z","status":"ssl_error","status_checked_at":"2026-04-15T15:24:39.138Z","response_time":63,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["coredns","coredns-plugin","dns-server","tailscale","tailscale-server","tailscaled"],"created_at":"2025-07-31T01:00:43.332Z","updated_at":"2026-04-15T16:09:05.554Z","avatar_url":"https://github.com/christian-deleon.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Tailscale CoreDNS High-Availability Service\n\nThis project provides a high-availability Go service that integrates a CoreDNS plugin for resolving DNS names to Tailscale IPs, using tags for nested subdomains. The service includes automatic process management, graceful shutdown, and split DNS functionality for HA deployments.\n\n## Features\n\n- **High Availability**: Full Go service with automatic process management and graceful shutdown\n- **Tailscale Integration**: Automatically resolves Tailscale hostnames to their IP addresses\n- **Multiple Domains**: Support for managing multiple domains in a single instance\n- **Subdomain Tags**: Support for custom subdomains using Tailscale tags (`tag:subdomain-*`)\n- **Hosts File Support**: Works with CoreDNS's built-in `hosts` plugin for custom DNS entries\n- **Forward Server**: Works with CoreDNS's built-in `forward` plugin for unresolved queries\n- **IPv4/IPv6 Support**: Full support for both IPv4 and IPv6 addresses\n- **Periodic Refresh**: Configurable refresh interval to keep DNS records up-to-date\n- **Process Management**: Monitors and manages CoreDNS and Tailscale processes\n- **Graceful Shutdown**: Proper cleanup and signal handling for container orchestration\n- **Split DNS Support**: Optional split DNS management for high availability deployments\n- **OAuth Authentication**: Secure authentication using Tailscale OAuth credentials\n- **Go Native**: Pure Go implementation\n- **Configuration Templating**: Built-in Corefile generation with Go templates\n\n## Authentication\n\nThe plugin uses Tailscale OAuth for authentication. You can create OAuth credentials from the [Tailscale admin console](https://login.tailscale.com/admin/settings/oauth).\n\nThe OAuth client requires the following permissions:\n\n- `dns:read` - Read DNS configuration\n- `dns:write` - Write DNS configuration (for split DNS functionality)\n\n## Split DNS Functionality\n\nThe plugin supports optional split DNS management for high availability deployments. When enabled, each instance will:\n\n- Add its own Tailscale IP to the split DNS configuration on startup\n- Remove its IP from the split DNS configuration on shutdown\n- Only manage its own IP, preserving other instances' IPs in the split DNS configuration\n\n**Note**: Currently, split DNS management uses a read-modify-write pattern that can lead to race conditions when multiple instances start/stop simultaneously. Future versions will implement proper synchronization.\n\n## Installation\n\n### Docker Deployment (Recommended)\n\n1. **Clone the repository**:\n\n   ```bash\n   git clone https://github.com/christian-deleon/tailscale-coredns.git\n   cd tailscale-coredns\n   ```\n\n2. **Create environment file**:\n\n   ```bash\n   cp docker/example.env docker/.env\n   ```\n\n3. **Configure custom files** (optional):\n\n   ```bash\n   # Custom hosts file\n   cp docker/ts-dns/hosts/custom_hosts docker/ts-dns/hosts/custom_hosts.example\n   # Edit the file with your custom DNS entries\n\n   # Additional configuration\n   cp docker/additional.conf.example docker/ts-dns/additional/additional.conf\n   # Edit the file with your additional CoreDNS configuration\n   ```\n\n   **Hosts File Format**: The hosts file uses standard hosts file format:\n\n   ```text\n   # Custom DNS entries\n   192.168.1.100    serviceA.mydomain.com\n   192.168.1.101    serviceB.mydomain.com\n   192.168.1.102    serviceC.mydomain.com\n   ```\n\n   **Rewrite Rules Format**: The rewrite file uses CoreDNS rewrite plugin syntax:\n\n   ```text\n   # Rewrite rules for CoreDNS\n   # Each line should contain a rewrite rule in the format expected by CoreDNS rewrite plugin\n   # Lines starting with # are comments and will be ignored\n\n   # Example: Rewrite www.example.com to example.com\n   name www.example.com example.com\n\n   # Example: Rewrite with regex pattern\n   name regex (.*)\\.example\\.com {1}.example.com\n\n   # Example: Rewrite with response rewrite\n   answer name example.com www.example.com\n\n   # Example: Rewrite with CNAME\n   name example.com cname.example.com\n   ```\n\n4. **Edit the environment file** with your Tailscale credentials:\n\n   ```bash\n   # Required: Tailscale OAuth credentials\n   # Get these from https://login.tailscale.com/admin/settings/oauth\n   TS_CLIENT_ID=tskey-client-abc123def456ghi\n   TS_CLIENT_SECRET=tskey-client-abc123def456ghi-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n\n   # Required: Domains for DNS resolution (comma-separated list)\n   # Examples:\n   # TS_DOMAINS=mydomain.com                           # Single domain\n   # TS_DOMAINS=mydomain.com,staging.mydomain.com      # Multiple domains\n   TS_DOMAINS=mydomain.com\n\n   # Required: Hostname for this CoreDNS instance\n   TS_HOSTNAME=ts-dns\n\n   # Optional: Enable split DNS functionality (default: false)\n   # When enabled, this instance will add its IP to the split DNS configuration\n   TS_ENABLE_SPLIT_DNS=false\n\n   # Optional: Tailnet name (uses \"-\" for default if not set)\n   # Set this to your Tailscale organization name if needed:\n   # TS_TAILNET=mydomain.com                  # Domain format\n   # TS_TAILNET=name@mydomain.com             # Email format\n   TS_TAILNET=\n\n   # Optional: Path to hosts file (default: /etc/ts-dns/hosts/custom_hosts)\n   TS_HOSTS_FILE=/etc/ts-dns/hosts/custom_hosts\n\n   # Optional: Path to rewrite rules file (default: /etc/ts-dns/rewrite/rewrite.conf)\n   TS_REWRITE_FILE=/etc/ts-dns/rewrite/rewrite.conf\n\n   # Optional: Forward server for unresolved queries (default: /etc/resolv.conf)\n   TS_FORWARD_TO=8.8.8.8\n\n   # Optional: Enable ephemeral mode for Tailscale (default: true)\n   TS_EPHEMERAL=true\n\n   # Optional: Refresh interval in seconds (default: 30)\n   TSC_REFRESH_INTERVAL=30\n   ```\n\n5. **Start the service**:\n\n   ```bash\n   cd docker\n   docker compose --env-file .env up --build\n   ```\n\n### Manual Build\n\n1. **Prerequisites**:\n   - Go 1.22 or later\n   - Git\n\n2. **Build the service**:\n\n   ```bash\n   # Clone the repository\n   git clone https://github.com/christian-deleon/tailscale-coredns.git\n   cd tailscale-coredns\n\n   # Build the main service\n   go build -o tailscale-coredns ./cmd/tailscale-coredns\n\n   # Build the split DNS tool\n   go build -o splitdns ./cmd/splitdns\n\n   # Build custom CoreDNS with plugin (optional, for standalone use)\n   git clone https://github.com/coredns/coredns.git\n   cd coredns\n   git checkout v1.11.3\n   sed -i '/^forward:/i tailscale:tailscale-coredns' plugin.cfg\n   go mod edit -require=tailscale-coredns@v0.0.0\n   go mod edit -replace=tailscale-coredns=/path/to/tailscale-coredns\n   go generate\n   go mod tidy\n   go build -o coredns .\n   ```\n\n3. **Run the service**:\n\n   ```bash\n   # Set required environment variables\n   export TS_CLIENT_ID=\"your-client-id\"\n   export TS_CLIENT_SECRET=\"your-client-secret\"\n   export TS_DOMAINS=\"your-domain.com\"\n   export TS_HOSTNAME=\"ts-dns\"\n\n   # Run the service\n   ./tailscale-coredns\n   ```\n\n## Configuration\n\n### Environment Variables\n\n- `TS_CLIENT_ID` (required): Tailscale OAuth client ID\n- `TS_CLIENT_SECRET` (required): Tailscale OAuth client secret\n- `TS_DOMAINS` (required): Comma-separated list of domains for DNS resolution\n- `TS_DOMAIN` (deprecated): Single domain for DNS resolution (use TS_DOMAINS instead)\n- `TS_HOSTNAME` (required): Hostname for this CoreDNS instance\n- `TS_ENABLE_SPLIT_DNS` (optional): Enable split DNS functionality (default: false)\n- `TS_TAILNET` (optional): Your Tailscale organization name (e.g., `mydomain.com` or `name@mydomain.com`). If not set, uses \"-\" for default tailnet\n- `TS_HOSTS_FILE` (optional): Path to hosts file for custom DNS entries (default: /etc/ts-dns/hosts/custom_hosts)\n- `TS_REWRITE_FILE` (optional): Path to rewrite rules file (default: /etc/ts-dns/rewrite/rewrite.conf)\n- `TS_FORWARD_TO` (optional): Forward server for unresolved queries (default: /etc/resolv.conf)\n- `TS_EPHEMERAL` (optional): Enable ephemeral mode for Tailscale (default: true). When set to true, the node will be automatically removed when it goes offline and the service will logout on shutdown\n- `TSC_REFRESH_INTERVAL` (optional): Refresh interval in seconds (default: 30)\n\n### Split DNS Configuration\n\nWhen `TS_ENABLE_SPLIT_DNS` is set to `true`, the plugin will:\n\n1. **On Startup**: Add the current instance's Tailscale IP to the nameserver list for each configured domain\n2. **On Shutdown**: Remove the current instance's IP from the nameserver list for each configured domain\n3. **High Availability**: Multiple instances can run simultaneously, each managing only its own IP\n\n**Requirements for Split DNS**:\n\n- The OAuth client must have `dns:read` and `dns:write` permissions\n- Each domain must have at least a second-level domain and TLD (e.g., `example.com`)\n\n**Finding Your Tailnet Name**:\n\nIf split DNS operations fail with 404 errors, you may need to explicitly set your tailnet name. The tailnet name is your Tailscale organization name, which can be:\n\n1. **Domain format**: `mydomain.com`\n2. **Email format**: `name@mydomain.com`\n3. **Default**: Use `-` or leave empty for the default tailnet\n\nYou can find your tailnet name in the Tailscale admin console or by checking your organization settings.\n\n### Directory Structure\n\nThe plugin uses `/etc/ts-dns/` as the base directory for configuration files:\n\n```text\n/etc/ts-dns/\n├── hosts/\n│   └── custom_hosts          # Custom DNS entries (hosts file format)\n├── rewrite/\n│   └── rewrite.conf          # Rewrite rules for CoreDNS rewrite plugin\n└── additional/\n    └── additional.conf       # Additional CoreDNS configuration for plugins\n```\n\n### Volume Mounts\n\n- `/etc/ts-dns/hosts/custom_hosts` (optional): Custom hosts file for DNS entries\n- `/etc/ts-dns/rewrite/rewrite.conf` (optional): Rewrite rules file for CoreDNS rewrite plugin\n- `/etc/ts-dns/additional/additional.conf` (optional): Additional CoreDNS configuration for built-in plugins like route53, etcd, kubernetes\n\n### Corefile Configuration\n\nThe plugin supports a simple Corefile configuration:\n\n```corefile\n. {\n    tailscale mydomain.com staging.mydomain.com\n    hosts /etc/ts-dns/hosts/custom_hosts {\n        fallthrough\n    }\n    rewrite name www.mydomain.com mydomain.com\n    forward . 8.8.8.8\n    log\n    errors\n}\n```\n\n### Additional Plugins\n\nYou can extend the CoreDNS configuration with additional built-in plugins by mounting an `additional.conf` file. This allows you to use plugins like `route53`, `etcd`, `kubernetes`, `cache`, and `prometheus`.\n\n#### Setup\n\n1. **Create an additional configuration file**:\n\n   ```bash\n   cp docker/additional.conf.example docker/ts-dns/additional/additional.conf\n   ```\n\n2. **Edit the configuration** with your specific plugin settings:\n\n   ```corefile\n   # Example: Route53 plugin\n   example.private. {\n       route53 example.private.:Z0123456789ABCDEF\n       fallthrough\n       log\n       errors\n   }\n   ```\n\n3. **Mount the file** in your compose.yml (already configured):\n\n   ```yaml\n   volumes:\n     - ./ts-dns/additional/additional.conf:/etc/ts-dns/additional/additional.conf:ro\n   ```\n\n#### Examples\n\n**Route53 Plugin**:\n\n```corefile\nexample.private. {\n    route53 example.private.:Z0123456789ABCDEF\n    fallthrough\n    log\n    errors\n}\n```\n\n## Usage\n\n### DNS Resolution\n\nOnce the service is running, you can resolve Tailscale hostnames:\n\n```bash\n# Resolve a Tailscale hostname\ndig hostname.mydomain.com @localhost\n\n# Resolve with subdomain tags\ndig hostname.subdomain.mydomain.com @localhost\n```\n\n### Subdomain Tags\n\nDevices can be tagged in Tailscale to create custom subdomains:\n\n1. Tag a device with `tag:subdomain-web-server` in Tailscale\n2. The device will be resolvable at `hostname.web.server.mydomain.com`\n\nTags are converted from hyphens to dots to create the subdomain hierarchy.\n\n### Split DNS Management\n\nWhen split DNS is enabled, you can manage it using the `splitdns` tool:\n\n```bash\n# Check split DNS status\n./splitdns -action=status -domains=mydomain.com\n\n# Initialize split DNS manually\n./splitdns -action=init -domains=mydomain.com,staging.mydomain.com\n\n# Cleanup split DNS manually\n./splitdns -action=cleanup -domains=mydomain.com\n```\n\n### High Availability Deployment\n\nFor high availability deployments with split DNS:\n\n1. Deploy multiple instances of the service\n2. Set `TS_ENABLE_SPLIT_DNS=true` on each instance\n3. Each instance will add its IP to the split DNS configuration\n4. Tailscale will load balance DNS queries across all registered IPs\n5. When an instance shuts down, it automatically removes its IP\n\n**Note**: The `TS_HOSTNAME` value doesn't need to be unique across instances. Tailscale automatically handles the identification and management of each instance's IP address in the split DNS configuration. You can use the same hostname for all instances or different hostnames - it doesn't affect the split DNS functionality.\n\n#### Demo Configuration\n\nThe included `compose.yml` file is configured with 3 replicas for demonstration and testing purposes. For production deployments, comment out the `deploy` section to run a single instance, or deploy across multiple hosts for true high availability.\n\n**Important**: The demo configuration with 3 replicas is **NOT** true high availability because all replicas run on the same host. If the host fails, all instances will be unavailable.\n\n#### Production HA Best Practices\n\nFor true high availability in production environments:\n\n1. **Deploy across multiple hosts/servers**: Each instance should run on a separate physical or virtual machine\n2. **Use different availability zones**: Deploy instances across different data centers or cloud availability zones\n3. **Monitor instance health**: Implement health checks\n4. **Use container orchestration**: Consider Kubernetes, or similar for production deployments\n\n**Load Balancing Note**: When using split DNS management (`TS_ENABLE_SPLIT_DNS=true`), Tailscale automatically routes DNS traffic to the registered ts-dns instances. Tailscale queries multiple nameservers sequentially - it only falls back to the next server if the previous one fails to respond (e.g., timeout or connection error), not if it returns a \"no such domain\" (NXDOMAIN) response. No external load balancer is needed when using split DNS.\n\nIf you prefer to self-manage DNS traffic without split DNS, you can use an external load balancer to direct traffic directly to ts-dns instances, but this project is designed to work with Tailscale's split DNS functionality.\n\nFor production deployments, deploy the same compose.yml file across multiple hosts. Tailscale will automatically handle the identification and management of each instance's IP address in the split DNS configuration.\n\n## Advanced Configuration\n\n### Corefile Generation\n\nThe service automatically generates a Corefile based on your configuration:\n\n```text\n. {\n    tailscale mydomain.com staging.mydomain.com\n    hosts /etc/ts-dns/hosts/custom_hosts {\n        fallthrough\n    }\n    forward . 8.8.8.8\n    log\n    errors\n}\n```\n\n### Additional Configuration\n\nYou can add custom CoreDNS configuration by creating a file at `/etc/ts-dns/additional/additional.conf`:\n\n```text\n# Custom server block for internal domain\ninternal.local {\n    file /etc/coredns/zones/internal.local\n    log\n}\n```\n\n### Custom Plugin Usage\n\nIf you need to use the plugin in a custom CoreDNS build:\n\n```text\n# Corefile\n. {\n    tailscale mydomain.com staging.mydomain.com {\n        # Plugin accepts multiple domains\n    }\n    forward . 8.8.8.8\n    log\n    errors\n}\n```\n\n### Docker Compose Commands\n\nThe Docker deployment includes helpful commands via `just`:\n\n```bash\n# Build the Docker image\njust build\n\n# Start the service\njust start\n\n# Stop the service\njust stop\n\n# Clean up (remove containers, volumes, and images)\njust clean\n```\n\n## Development\n\n### Project Structure\n\n```text\ntailscale-coredns/\n├── cmd/                      # Command-line applications\n│   ├── tailscale-coredns/    # Main HA service application\n│   │   └── main.go\n│   └── splitdns/             # Split DNS management tool\n│       └── main.go\n├── internal/                 # Internal packages\n│   ├── config/               # Configuration management\n│   │   └── config.go\n│   ├── plugin/               # CoreDNS plugin implementation\n│   │   ├── plugin.go         # Main plugin logic\n│   │   ├── serve.go          # DNS request handler\n│   │   ├── setup.go          # Plugin initialization\n│   │   └── splitdns.go       # Split DNS management\n│   ├── process/              # Process management\n│   │   └── manager.go\n│   └── template/             # Configuration templating\n│       └── corefile.go\n├── pkg/                      # Public packages\n│   └── api/                  # Tailscale API client\n│       └── client.go\n├── docker/                   # Docker deployment files\n│   ├── Dockerfile            # Go-based container\n│   ├── compose.yml\n│   ├── example.env\n│   ├── justfile              # Common commands\n│   └── ts-dns/               # Default configuration files\n│       ├── hosts/\n│       │   └── custom_hosts\n│       └── additional/\n│           └── additional.conf\n├── go.mod                    # Go module dependencies\n├── go.sum                    # Go module checksums\n└── README.md\n```\n\n### Local Development\n\n1. **Run tests**:\n\n   ```bash\n   go test ./...\n   ```\n\n2. **Build the applications**:\n\n   ```bash\n   # Build the main service\n   go build ./cmd/tailscale-coredns\n\n   # Build the split DNS tool\n   go build ./cmd/splitdns\n   ```\n\n3. **Test locally**:\n\n   ```bash\n   # Set environment variables\n   export TS_CLIENT_ID=\"your-client-id\"\n   export TS_CLIENT_SECRET=\"your-client-secret\"\n   export TS_DOMAINS=\"your-domain.com,staging.your-domain.com\"\n   export TS_HOSTNAME=\"test-server\"\n\n   # Run the service\n   ./tailscale-coredns\n   ```\n\n4. **Development tools**:\n\n   ```bash\n   # Check split DNS status\n   ./splitdns -action=status -domains=your-domain.com\n\n   # Initialize split DNS manually\n   ./splitdns -action=init -domains=your-domain.com,staging.your-domain.com\n\n   # Cleanup split DNS manually\n   ./splitdns -action=cleanup -domains=your-domain.com\n   ```\n\n## Troubleshooting\n\n### Common Issues\n\n1. **Plugin not resolving Tailscale hostnames**:\n   - Verify Tailscale is running and authenticated\n   - Check the Tailscale socket path: `/run/tailscale/tailscaled.sock`\n   - Ensure the OAuth key has the correct permissions\n\n2. **DNS queries timing out**:\n   - Check the forward server configuration\n   - Verify network connectivity\n   - Review CoreDNS logs for errors\n\n3. **Subdomain tags not working**:\n   - Ensure tags are properly formatted: `tag:subdomain-web-server`\n   - Check that devices have the correct tags applied\n   - Verify the tag conversion (hyphens become dots)\n\n4. **Split DNS not working**:\n   - Verify `TS_ENABLE_SPLIT_DNS=true` is set\n   - Check that the OAuth client has `dns:read` and `dns:write` permissions\n   - Ensure domains are valid (at least second-level domain + TLD)\n   - Check if `TS_TAILNET` needs to be set explicitly\n\n### Debug Commands\n\n```bash\n# Check Tailscale status\ntailscale status\n\n# Test DNS resolution\ndig hostname.mydomain.com @localhost\n\n# View CoreDNS logs\ndocker logs tailscale-coredns\n\n# Check Tailscale connectivity\ntailscale ping hostname\n\n# View split DNS configuration (if enabled)\n./splitdns -action=status -domains=mydomain.com\n```\n\n## Roadmap\n\n### Planned Features\n\n- **CNAME Support**: Support for CNAME records\n  - Ability to resolve CNAME records to Tailscale devices or a custom domain\n- **Built-in DNS Manager**: Automated health monitoring and IP management for split DNS instances\n  - Automatic removal of unhealthy instance IPs from split DNS configuration\n  - API request locking to prevent race conditions during concurrent instance startup/shutdown\n  - Health check integration with container orchestration platforms\n  - Improved reliability for high-availability deployments\n\n## Contributing\n\n1. Fork the repository\n2. Create a feature branch: `git checkout -b feature-name`\n3. Make your changes\n4. Submit a pull request\n\n## License\n\nThis project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.\n\n## Author\n\nCreated by [Christian De Leon](https://github.com/christian-deleon)\n\n## Support\n\nFor issues and questions:\n\n- [GitHub Issues](https://github.com/christian-deleon/tailscale-coredns/issues)\n- [Tailscale Documentation](https://tailscale.com/docs/)\n- [CoreDNS Documentation](https://coredns.io/manual/toc/)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fchristian-deleon%2Ftailscale-coredns","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fchristian-deleon%2Ftailscale-coredns","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fchristian-deleon%2Ftailscale-coredns/lists"}