GitLab Geo with a unified URL

A single GitLab hostname for every Geo site lets users and runners reach the nearest replica without learning two URLs. This page covers the DNS, certificate and failover decisions that make it work, and what to confirm before you build it.

On this page

Why teams want one GitLab Geo URL and what it takes

A unified URL lets location-aware DNS send each user to the nearest GitLab site, so a distributed organization can run a primary and a Geo secondary while developers keep one hostname for clones, pushes and the web interface. Teams want this because the alternative, separate hostnames per site, pushes the choice of server onto every engineer and every CI configuration. The cost is that the DNS layer, the certificate and the failover runbook now all depend on a single shared domain, and each of those needs a deliberate design before the secondary is built.

GitLab Geo provides a warm-standby secondary site in another region that is continuously synchronized for disaster recovery, according to the GitLab Geo documentation. Geo is available in the Premium and Ultimate tiers for self-managed GitLab, so confirm the tier before you plan the topology. The secondary serves reads locally and proxies writes to the primary, which means the hostname a user resolves must still reach the primary for any operation that changes data. Confirm with your Geo design which requests the secondary handles locally and which it forwards, since that determines how much latency the unified URL actually removes.

The shared hostname changes three pieces of work. DNS must return a site-specific answer for each client without breaking failover, so the records and health checks need to be designed for a switchover, not only for steady-state routing. The certificate must cover the shared name on every site, which means deciding how the same hostname's TLS material is issued, distributed and renewed across the primary and secondary. Failover must move the name to the promoted site, so the cutover runbook has to include the DNS change and its propagation time. Ask your network team and your DNS provider to confirm how record changes and health checks behave during a switchover before you commit to the design.

Choosing a DNS routing policy for the shared hostname

Latency-based routing answers each DNS query with the site that has the lowest measured network latency from the resolver that asked. It fits organizations whose users are spread across regions and who want the closest working site to serve them during normal operation. Because a Geo secondary is a warm standby that is continuously synchronized, a read-heavy team may be served from a nearby site while writes still go to the primary, so confirm how your users will actually reach the primary before relying on latency alone.

  • Normal-state fit: suits distributed teams where latency differences between sites are meaningful to users.
  • Health checks: when a site fails its health check, its record is withdrawn from answers, so new queries go to the remaining sites.
  • Nearest site down: users whose resolver is closest to the failed site receive the next-lowest-latency answer, which may add delay until caches expire.
  • Resolver location: latency is measured from the resolver, not the user, so confirm how your provider handles large public resolvers.
  • Write traffic: confirm with GitLab Geo documentation which operations are proxied to the primary, since this decides whether latency routing helps your users.

Before choosing this policy, ask your DNS provider to document how it measures latency and how health check results propagate to answers.

Configuration options and when each fits

This table compares the four decisions that shape a unified Geo URL: hostname layout, DNS routing policy, certificate model and TLS termination point. Read each row as a choice you make once, then check the trade-off against your network and your change process before you pick a combination.

DecisionOptionFits whenMain trade-off
Hostname layoutSingle hostname for all sitesUsers should type one address and DNS steers them to a siteEvery site depends on the same name, so DNS and certificate mistakes affect all sites at once
Hostname layoutPer-site hostnamesSites must be reached directly for diagnosis or runner registrationUsers and runners need to know which site to use, and the unified experience is lost
Routing policyLatency-based routingUsers are spread across regions and the lowest-latency site is acceptable for reads and writesRouting reflects network latency, not the site a user can write to, so sessions can land on a secondary
Routing policyGeolocation routingYour user population maps cleanly to countries or regions and you need a predictable home siteUsers who travel or sit near a border can be sent to a site that is far away or not their home
Routing policyFailover routing with health checksYour goal is to move traffic to the standby when the primary fails health checksHealth checks must reflect real GitLab availability, and failback needs a deliberate, tested step
Certificate modelWildcard or SAN certificate covering the shared nameSeveral sites present the same hostname and you want one certificate to renew and deployThe private key is shared across sites, so it must be protected and rotated on every site together
Certificate modelOne certificate per site hostnameEach site keeps its own name for operations and certificates are issued per sitePer-site names do not serve the unified URL, so you still need a shared name for users
TLS terminationLoad balancer or DNS-fronted proxy in each siteYou want health checks and certificate handling close to each site's trafficEach site's termination point needs the same certificate and configuration, which adds drift risk
TLS terminationTerminate on the GitLab instance itselfYou want the certificate tied to the GitLab nodes and fewer components in frontCertificate rotation touches every GitLab node, and failover depends on each site's own certificate state

Setting up a unified GitLab Geo hostname

This sequence takes a working Geo pair to a state where one GitLab hostname resolves to the right site in each region, serves a certificate that covers that name on both sites, and survives a planned switchover. Each step closes with a check you can run before moving on.

  1. Confirm both Geo sites are healthy

    Before touching DNS or certificates, confirm that the primary and secondary sites are installed, replicating and reporting healthy. Your GitLab administrator runs the Geo health checks on each site and reviews replication lag for repositories, uploads and the database. Also confirm that both sites run the same GitLab version and that the secondary is current with the primary's configuration. The step is done when every Geo component reports healthy on both sites and the replication status shows no failures. Record the baseline output so you can compare it after each later change.

  2. Decide the external URL and certificate model

    Choose the single hostname that users, Git remotes and runners will use, and set it as the external URL on both sites. Then decide how the certificate will be issued: a public certificate authority, a private CA you operate, or a certificate managed by a cloud load balancer in front of each site. Document which site terminates TLS and whether the same private key or a per-site key with a shared name will be used. The step is done when you have a written decision that names the hostname, the issuer, the key ownership and the sites that present the certificate. Confirm the decision with your security team and with the owners of any internal clients that pin certificates.

  3. Configure location-aware DNS and health checks

    Create the record for the unified hostname in your DNS service, such as Route 53 or Cloud DNS, using a routing policy that sends clients to the nearest healthy site. Attach a health check to each site's endpoint so the record stops answering with an unhealthy site. Keep the time-to-live low enough that a switchover takes effect predictably, and confirm the exact routing options your DNS provider offers before you design around them. The step is done when the record exists, the health checks report each site correctly, and a deliberate failure of one endpoint removes it from answers. Check the records from your provider console and from an outside resolver.

  4. Issue and install the certificate on each site

    Request a certificate whose subject alternative names include the unified hostname, and cover any additional names the sites use, such as the registry or pages hostnames if they are enabled. Install the full chain on each site, using the configuration keys documented for your installation method, then reconfigure and restart GitLab. Keep the private key protected in the way your policy requires, and back it up with the other TLS material you rely on. The step is done when each site presents a certificate that lists the unified hostname as a SAN and includes the intermediate chain. Verify this with an OpenSSL connection test against each site's address, not only against the DNS name.

  5. Verify name resolution and TLS from each region

    From a host in each region you serve, resolve the unified hostname and record which site answers. Then open a TLS connection to that hostname, confirm the chain validates against your trust store, and check that the SAN list matches the name you requested. Repeat the test from a host that should reach the secondary and from one that should reach the primary. Run a Git clone and a web login through the unified name in each region to confirm that the application responds as expected. The step is done when every region resolves to the intended site, every TLS check passes and the Git and web tests succeed.

  6. Test the planned switchover path

    Run a planned switchover to the secondary using the promotion steps in your Geo runbook, in a window agreed with the business, with maintenance mode enabled on the primary. Confirm that replication has caught up before promotion, then check that the unified hostname now answers from the new primary and that the certificate still validates there. Afterward, confirm that the old primary can be re-added as a secondary, and that DNS and health checks reflect the new roles. The step is done when a switchover completes without a certificate warning or a DNS answer pointing at the wrong site, and the findings are recorded. Confirm the exact promotion commands against the GitLab Geo documentation for your topology before the test.

Certificate handling for a shared Geo domain

Serving every Geo site behind one hostname means that whichever site DNS sends a user to must present a certificate valid for that name. A browser or Git client that connects to the unified URL and receives a certificate that does not cover it will fail the TLS check, so the certificate is not a per-site detail. Each site's load balancer or GitLab node needs a certificate whose subject alternative names include the shared hostname, and the team should confirm which certificate and external URL settings apply to its GitLab version in the GitLab Geo documentation before ordering anything.

The first decision is between one shared certificate and per-site certificates that all cover the unified name. A single certificate, issued once and copied to every site's termination point, is simpler to renew and to audit, but the private key then exists in several places and must be protected in each. Per-site certificates keep keys local and let each site renew on its own schedule, at the cost of more issuance events and a higher chance that one site falls behind. Either way, the unified name must be listed exactly as clients will type it, and any site-specific hostnames used for administration or direct access should be tracked separately so they do not get forgotten.

Renewal has to be coordinated across sites, because an expired certificate at one secondary will break location-aware routing for the users DNS sends there, even while the primary is healthy. Assign an owner for issuance, record the renewal date for every site, and check that the new certificate reaches all termination points before the old one expires. Test the renewal path in a non-production Geo setup, including the failover case where a secondary is promoted and must already hold a valid certificate. Ask your GitLab support or implementation partner to confirm the certificate handling for your exact version before go-live.

Security and operational risks of a shared Geo hostname

A single GitLab hostname that resolves differently by location moves trust into DNS, certificates and identity redirects. Each risk below is a place where one site's configuration can quietly weaken another, so each needs a named owner and a check that runs before and after every change.

Certificate private key distribution

Every Geo site that answers for the shared hostname must present a certificate for that name, so the private key has to exist at each site. Decide which secrets store holds the key, who can read it, and how a renewed certificate reaches every site on the same day. Check that each site serves the expected certificate chain and that no site keeps an expired copy. Record where each key is stored so revocation covers all copies.

DNS record change control

The location-aware routing policy is the control point for which site users reach, so a wrong edit can send traffic to a stale or unhealthy site. Store the record set in version-controlled infrastructure code, require a second approver for changes, and test the routing policy in a non-production zone first. Confirm the TTL you intend to use before cutover, because it determines how long a bad change keeps resolving.

Health check endpoints exposed to the internet

Health checks used by DNS routing or load balancers must reach each site, but the endpoints they call can reveal version, state and site identity to anyone who finds them. Restrict the health check source addresses where your platform allows it, and confirm which GitLab endpoints answer without authentication in your version. Review the result against the hardening guidance for the instance before opening any path to the public internet.

Session and login behavior across sites

Users who are routed to a different site mid-session can hit a login prompt, a lost session or a redirect to the primary. Test sign-in, token refresh and long-running sessions while moving a test user between sites, and note which actions are proxied to the primary. Decide in advance how support will tell a routing problem from a credential problem, since both appear to the user as a failed login.

OAuth and SAML redirect URLs

Identity provider applications register the callback URLs they will accept, and those URLs carry the GitLab hostname. Because the shared hostname is the only name users see, every registered redirect URL, logout URL and SAML audience value must match it exactly, including scheme and path. Export the current registrations from each identity provider, compare them to the GitLab external URL setting, and repeat the comparison after any change to either side.

Audit logging of DNS changes

A change to the shared hostname's routing is a change to where authentication and source code traffic goes, so it needs an audit trail that survives the person who made it. Enable change logging in the DNS platform, forward those logs to the same store as your cloud audit logs, and set an alert on any change outside the approved pipeline. Review the log against the change tickets at each cutover so unexplained edits are found quickly.

Questions teams ask before building a unified Geo URL

What drives the cost and effort of a unified Geo URL?

The cost comes mostly from the number of Geo sites, how many DNS and certificate changes the design needs, and how many internal teams must approve and test each step. Each secondary site adds a routing decision, a health check, a certificate path and a failover test. Environments with strict change control, several network zones or split-horizon DNS usually take more coordination than a single flat network. One-time work covers the design, DNS records, health checks, certificate issuance and the first failover test. Recurring work covers certificate renewal, DNS changes when sites are added, and retesting after GitLab upgrades. Ask any partner for a written scope that lists each site, each DNS zone, each certificate and each test, so the quote follows from that list.

How long does a unified Geo URL setup take?

Duration depends on how quickly your organization can approve changes and how many sites and zones are involved, not on the DNS product alone. The work runs in phases: design of the routing policy, certificate planning, DNS and network changes, health checks, and a controlled failover test. Waiting on change windows, certificate authority requests and firewall reviews often takes longer than the configuration itself. DeployOpen does not publish a timeline. Ask for a schedule in the written scope that shows which steps depend on your teams, so you can see where delays would come from.

What does the internal team need to provide?

Plan to provide three kinds of access before work starts:

  • DNS administration for the zone that holds the shared hostname, including rights to create health-checked or location-aware records in your provider, such as Route 53 or Cloud DNS.
  • Certificate authority access to request or approve a certificate that covers the shared name and each site's endpoints, along with a way to deploy it to every site.
  • Network changes so each site can reach the others on the ports Geo uses, and so health checks can reach each primary and secondary endpoint.

Your security team should also approve how private keys are stored and rotated. Confirm each item with your own DNS, PKI and network owners early, because these approvals usually set the pace.

Can our own team build a unified Geo URL without a partner?

Yes, if your team already runs GitLab Geo, manages DNS health checks and operates certificates across sites. The work is within reach of an experienced platform team, but it requires knowledge of Geo replication, DNS failover behavior and certificate chains together. Teams that run Geo for the first time often underestimate the testing. A partner is useful when you need an independent design review, a documented build and a tested failover runbook delivered as part of a fixed scope. Decide based on the skills you can staff for the full test cycle, not only the first configuration. Note that DeployOpen does not issue certificates or audit reports; those come from your certificate authority and independent auditors.

How does a unified URL change failover testing?

A unified URL moves the routing decision from users' bookmarks and Git remotes into DNS, so failover tests must prove that the name now points to the right site. Each test should confirm the health check result, the DNS answer seen from each network, the certificate served on the shared name, and whether Git over HTTPS and the web interface both reach the promoted site. Tests must also cover the time DNS caches take to expire, which depends on the record settings you choose and on resolvers outside your control. Run a planned switchover and an unplanned failure test, and record how long users saw errors. Confirm the exact promotion steps against the Geo documentation for your GitLab version before each test.

Which certificate issues must we plan for a shared domain?

Plan for the shared hostname to be valid on every path that users and runners take to reach GitLab, and plan for the certificate to be deployed consistently across sites. Common issues include a certificate that names only one site, a chain that a runner or Git client does not trust, and a renewal that updates one site but not the others. Decide whether each site terminates TLS with the same certificate or with its own certificate under the shared name, and document the choice. Check how your CA issues and renews certificates, and whether automation can reach each site. Confirm the exact certificate settings for your GitLab version in the Geo documentation.

Does a unified URL replace the need for Geo backups?

No. A unified URL controls where traffic goes, but it does not protect data. Geo replicates data to a secondary site, and a failure can still replicate a bad change or corruption. Keep a backup strategy with restores you have tested, and treat the unified URL as a routing layer on top of it. Your recovery plan should name who decides to fail over, how that decision is recorded, and how the old primary is rejoined. Review the backup and restore documentation before you finalize the failover runbook.

How DeployOpen scopes and delivers unified Geo URL work

DeployOpen plans, implements, documents and tests unified Geo URL work inside your own cloud accounts, data centers or networks. The engagement covers the design of the shared hostname, the location-aware DNS records in your provider (such as Route 53 or Cloud DNS), the certificate arrangement for the shared domain on each site, and the validation runs that prove a user lands on the right site from each region. Because the GitLab Geo sites, load balancers and DNS zones all sit under your control, the work runs in your environments and your change process, and your team keeps the credentials and the audit trail.

Most engagements are fixed-scope, with the scope, deliverables and timelines written down and agreed before any change is made to DNS or certificates. For this topic, a written scope usually names the sites in the Geo deployment, the record types and routing policies to be used, the certificate authority and renewal process, the failure behavior to be tested, and the acceptance evidence. Ask for these items in any proposal you receive from any partner, and confirm with your own network and DNS owners which records and health checks they will need to approve. The effort depends on how many sites are involved and how many hosts and services sit behind the shared name, so the quote should follow from that list rather than from a generic estimate.

Ongoing support is available as a retainer. Once the unified URL is live, DNS routing, certificate renewals and GitLab version upgrades keep changing the setup, and Geo sites must be upgraded in step with the primary. A retainer can cover monitoring of routing health, renewals, upgrade rehearsals against the GitLab upgrade paths and re-testing after infrastructure changes. Ask your partner which of these tasks are included, how changes are requested and how they are recorded.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.