Generated banner for Render Networking
Generated logo for Render Networking

Render Networking

RenderOfficialCreated by Render

  • Skill
  • Tool integration
  • Cloud and DevOps
  • MIT
  • No issues found

From the author

Connects Render services over the private network—internal DNS, service discovery, and cross-service communication. Use when the user needs to wire services together, resolve internal hostnames, troubleshoot connectivity between services, configure environment isolation, or understand which services can reach each other.
— the description by Render

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The render-networking skill provides guidance on establishing secure, internal communication between services hosted on Render. It covers service discovery, internal hostname resolution, and architectural patterns for connecting web services, private services, and background workers without exposing traffic to the public internet. The skill emphasizes verifying workspace and region alignment, proper URL construction, and adhering to platform-specific port and service-type constraints.

What it does

  • Explains how to connect services using internal hostnames and ports.
  • Provides patterns for gateway, worker-to-database, and microservice communication.
  • Details how to use discovery hostnames for custom load balancing or per-instance metrics.
  • Outlines requirements for environment isolation and private network connectivity.
  • Offers troubleshooting steps for common connection failures.
  • Defines the workflow for retrieving current platform documentation.

When to use it

  • When designing service-to-service communication architecture on Render.
  • When debugging connectivity issues between internal services.
  • When configuring environment isolation or private egress/ingress patterns.
  • When implementing custom service discovery or load balancing logic.
  • When determining if a service type can receive private traffic.

Advantages

  • Enables secure communication without exposing traffic to the public internet.
  • Provides clear patterns for common architectural needs like gateway and worker-to-DB setups.
  • Includes specific guidance on handling dynamic instance discovery.
  • Promotes the use of authoritative, up-to-date platform documentation.

Usage examples

“How do I connect my background worker to my internal Postgres database on Render?”
The agent will explain that the worker should use the internal URL found in the Dashboard under Connect > Internal, and that the worker acts as an outbound client.
“My private service cannot reach my web service. What should I check?”
The agent will guide you to verify that both services are in the same workspace and region, check for environment isolation settings, and confirm the destination service accepts inbound traffic.
“How do I implement custom load balancing across my service instances?”
The agent will explain how to use the discovery hostname (e.g., [internal-hostname]-discovery) to resolve all active instance IPs.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/render-oss/render-networking/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip render-networking.zip -d .agents/skills

Documentation by Render

Render private networking

Render’s private network lets services talk to each other without exposing traffic on the public internet. Use this skill when users need internal connectivity, discovery across scaled instances, or correct URL/port behavior for Blueprints and the Dashboard.

When to Use This Skill

  • Designing or debugging service-to-service traffic on Render

  • Questions about internal hostnames, internal URLs, or Connect > Internal in the Dashboard

  • Service discovery across multiple instances (custom load balancing, mesh-style setups)

  • Port limits, reserved ports, or multi-port web services (public vs private)

  • Free-tier web services and who can send vs receive private traffic

  • Environment isolation (with a Pro workspace or higher) or AWS PrivateLink for private egress/ingress patterns

Before designing, configuring, or troubleshooting private connectivity, read references/private-networking.md. For architecture examples and Blueprint patterns, see references/communication-patterns.md.

Private Connection Essentials

  • If the service types or traffic direction are unclear, establish which service initiates the connection and which service receives it before proposing an address.

  • Private-network peers must be in the same workspace and region. Use the destination's address from Connect > Internal in the Dashboard.

  • Construct a complete URL when the client expects one, such as http://[internal-hostname]:[port]/path; a bare hostname does not supply the protocol.

  • Web services and private services can receive private traffic. Background workers, cron jobs, and workflow runs can initiate outbound private connections but have no internal hostname and cannot receive them.

  • In a gateway pattern, a public web service calls a private service over the private network; the private service does not need a public endpoint.

Service Discovery

Use a service's normal internal hostname for ordinary service-to-service traffic. When an application specifically needs every active instance—for custom load balancing, per-instance metrics, or similar logic—use the service's discovery hostname, conventionally [internal-hostname]-discovery, which resolves to all active instance IPs. Each web or private service receives its own discovery hostname in RENDER_DISCOVERY_SERVICE. Do not persist the resolved IPs because they can change between deploys.

Common Patterns

Short summaries; full diagrams and Blueprint notes live in references/communication-patterns.md.

  1. Web gateway + private backends — Public Web Service terminates HTTP; internal calls use private hostnames and ports to Private Services or internal URLs.

  2. Worker to database — Background Worker (no internal hostname) connects outbound to Postgres or Key Value internal URLs.

  3. Microservices — Private Services (and eligible Web Services) call each other by internal hostname:port on the private network.

References

DocumentPurpose
references/private-networking.mdCurrent private-network capabilities, addressing, discovery, ports, isolation, and troubleshooting
references/communication-patterns.mdGateway, worker→DB, mesh, URL construction, and Blueprint fromService patterns
  • render-web-services — Public web services, PORT, and HTTP behavior

  • render-private-services — Private Service–specific setup and scaling

  • render-blueprints — render.yaml, fromService, and multi-service wiring

<!-- shared:documentation-retrieval -->

Current documentation retrieval

Whenever this skill directs you to consult current Render documentation:

  1. Retrieve the linked Markdown document directly with an available URL-fetching tool or HTTP client, such as curl. Do not substitute web-search summaries for the document.

  2. Confirm that retrieval succeeded and returned the expected document, then read its contents. Saving a file or printing its path is not sufficient.

  3. If the request fails or your tool cannot read the Markdown response, open and read the linked HTML version instead.

  4. If neither version can be retrieved, disclose that the current reference is unavailable and follow any topic-specific fallback in the skill. Use bundled guidance only for stable constraints, and do not guess at changeable platform details.

When a task requires multiple references, apply this workflow to each one and distinguish the documents you verified from those that remain unavailable.

<!-- /shared:documentation-retrieval -->

Files

references/private-networking.md

<!-- shared:private-networking -->

Private networking

Render services can communicate over a private network without traversing the public internet. Private-network peers must belong to the same workspace and run in the same region. An isolated project environment can additionally block traffic both to and from resources outside that environment, so workspace and region matching alone do not guarantee connectivity.

Before designing, configuring, or troubleshooting private-network communication, fetch the current Render private-network reference:

Using the documentation-retrieval workflow in the root SKILL.md, retrieve and read the Markdown reference or its HTML version.

Read the relevant sections. Confirm current service-type capabilities, port restrictions, environment-isolation behavior, discovery-hostname guidance, and plan requirements instead of relying on a memorized catalog.

Web services and private services have internal hostnames and can receive private-network traffic. A private service must bind at least one port; use a background worker instead when a workload does not need to accept inbound connections. Render Postgres and Key Value instances provide internal connection URLs. Workflows, background workers, and cron jobs can initiate private-network connections but do not have an internal address for receiving them. Static sites are not on the private network. Free web services can initiate private-network connections but cannot receive them.

Prefer the internal address or URL shown under Connect > Internal in the Render Dashboard. Include the protocol when the client or server requires one; an address such as service:10000 does not by itself establish whether to use HTTP, HTTPS, or another protocol. A process that receives traffic must listen on the intended port and on an interface reachable outside its own container, such as 0.0.0.0, rather than only on loopback.

For Blueprint-managed connections, fetch the current Blueprint specification and use supported service or database references instead of copying a generated hostname, port, credential, or connection string. Web and private services currently expose host, port, and hostport properties. A Blueprint can obtain another service's discovery hostname by referencing that service's RENDER_DISCOVERY_SERVICE environment variable with fromService.envVarKey; the discovery hostname is not a service property. The fetched specification is authoritative for the syntax and supported references.

A service can expose at most 75 ports on the private network. Ports 18012, 18013, and 19099 are unavailable for private-network communication. Port 10000 is not generally blocked: for a web service, private traffic to port 10000 routes to its primary HTTP server even when that server binds to another port. In that case, both port 10000 and the actual primary HTTP port route to the same server.

Use a service's normal internal hostname for ordinary service-to-service traffic. For advanced per-instance communication, each web or private service has a discovery hostname, conventionally formed by appending -discovery to its internal hostname, that resolves to all active instance IP addresses. A service receives its own discovery hostname in RENDER_DISCOVERY_SERVICE. Use DNS APIs that honor the system resolver configuration, and do not persist resolved instance IPs because they can change between deploys. Prefer hostname-based communication unless per-instance addressing or custom load balancing is specifically required.

When a private-network connection fails, verify the workspace, region, project-environment isolation settings, whether the destination service type accepts inbound traffic, the internal hostname or URL, protocol, port, listening interface, current deploy health, and DNS resolution. Do not substitute a public URL or expose a private service merely to bypass a private-network configuration problem.

AWS PrivateLink is a separate Pro-or-higher feature for connecting a Render private network to compatible AWS-hosted systems. Fetch its current documentation before proposing or configuring it; do not treat ordinary Render service-to-service networking and PrivateLink as interchangeable.

<!-- /shared:private-networking -->

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

The author says: Render services in the same region and workspace

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Render
Publisher
Render (Official)
Source
render-oss/skills · skills/render-networking · commit b985a63
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Render or Render.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download render-networking.zip