{"schemaVersion":"1.0","type":"TechArticle","types":["Article","TechArticle"],"slug":"how-i-deploy-zyvop-com-with-zero-downtime-rolling-vs-blue-green-vs-canary-kk9qi","url":"https://zyvop.com/how-i-deploy-zyvop-com-with-zero-downtime-rolling-vs-blue-green-vs-canary-kk9qi","title":"How I Deploy zyvop.com with Zero Downtime: Rolling vs. Blue-Green vs. Canary","subtitle":"Three ways to ship a new version of zyvop.com without dropping a single request, and how I choose between them.","tldr":"Shipping a new version shouldn't take my site down. I compare rolling, blue-green and canary deployments for zyvop.com, with graceful shutdown code, Nginx configs, rollback rules, a decision flowchart, and a checklist for zero dropped requests.","keywords":["blue-green deployment","canary release","Zero Downtime","rolling deployment","DevOps","Building ZyVOP in Public"],"entities":["Sanju Singh","blue-green deployment","canary release","Zero Downtime","rolling deployment","DevOps","Building ZyVOP in Public","ZyVOP"],"keyTakeaways":["Rolling: update servers one at a time while the others keep serving traffic. Cheapest, and my default. Rollback is slow because it's another rolling deploy.","Blue-green: run two full environments, deploy to the idle one, test it, then flip all traffic at once. Rollback is instant, but I pay for a second environment during the deploy.","Canary: send a small slice of real traffic to the new version first and ramp up while watching metrics. Smallest blast radius, but it needs good monitoring and enough traffic to learn anything.","All three depend on the same groundwork: graceful shutdown, health checks, backward-compatible database migrations, and immutable builds.","My plan: rolling for everyday releases, blue-green for risky ones, and canary only once zyvop.com has the traffic and monitoring to justify it."],"headings":["TL;DR","Why deploys cause downtime","The groundwork every strategy needs","1. Graceful shutdown","2. Two health endpoints","3. Backward-compatible migrations","4. Immutable, versioned builds","5. Static assets that outlive the deploy","The three strategies at a glance","Strategy 1: Rolling deployment","My rolling deploy script (a sketch)","Rolling: what I like and what I watch for","If I were on Kubernetes","Strategy 2: Blue-green deployment","How I flip with Nginx","Blue-green: what I like and what I watch for","Strategy 3: Canary deployment","How I split traffic with Nginx","What I watch during a canary","Canary: what I like and what I watch for","Side by side","Which one I use","Rollbacks, feature flags, and the database","Mistakes I'm trying not to make"],"outboundLinks":[],"contentText":"In my post on scaling zyvop.com, Step 8 covered rolling deployments in a few lines. That was the short version. Deploying is the thing I'll do more often than anything else on this site, and changes are a leading cause of outages. Google's SRE book reports that roughly 70% of their outages come from changes to a live system, and its recommended defenses are progressive rollouts, quick detection of problems, and safe rollback. That's a fair summary of what the rest of this post is about. This post goes deeper. It compares three deployment strategies (rolling, blue-green, and canary), what each one costs, how each one rolls back, and the configs and scripts I use. The goal is the same for all three: visitors never hit an error page or a dropped request because I shipped something. \"Zero downtime\" doesn't mean nothing can ever go wrong. It means the act of deploying doesn't cause failed requests. A bad release can still break things. A lot of what follows is about how quickly I find out, and how quickly I can undo it. TL;DR Rolling: update servers one at a time while the others keep serving traffic. Cheapest, and my default. Rollback is slow because it's another rolling deploy. Blue-green: run two full environments, deploy to the idle one, test it, then flip all traffic at once. Rollback is instant, but I pay for a second environment during the deploy. Canary: send a small slice of real traffic to the new version first and ramp up while watching metrics. Smallest blast radius, but it needs good monitoring and enough traffic to learn anything. All three depend on the same groundwork: graceful shutdown, health checks, backward-compatible database migrations, and immutable builds. My plan: rolling for everyday releases, blue-green for risky ones, and canary only once zyvop.com has the traffic and monitoring to justify it. Why deploys cause downtime When a deploy hurts users, it's almost always one of these: The process restarts and kills in-flight requests. Someone was mid-upload or mid-checkout. The load balancer keeps sending traffic to a server that's stopping or still starting. The new version is cold. Empty caches, no warmed-up connection pools, slow first requests. Old and new code disagree about the database schema. One of them starts throwing errors. Long-lived connections (WebSockets, streaming) get cut. Clients need to reconnect gracefully. Every strategy below is really a different answer to the same question: how do I get the new version running and taking traffic without any of these happening? The groundwork every strategy needs Skip this and none of the three strategies will save me. 1. Graceful shutdown When a server is told to stop, it should stop taking new requests, finish the ones in flight, and only then exit. In Node: let shuttingDown = false; const server = app.listen(3000); // Shallow check: the load balancer polls this. It flips to 503 once draining starts. app.get(\"/healthz\", (req, res) =&gt; shuttingDown ? res.status(503).send(\"draining\") : res.status(200).send(\"ok\") ); process.on(\"SIGTERM\", () =&gt; { shuttingDown = true; // tell the load balancer to stop sending traffic // Give the load balancer a few seconds to notice, then stop accepting connections setTimeout(() =&gt; { server.close(async () =&gt; { // fires once in-flight requests have finished await redisClient.close(); // node-redis v5+; older versions use quit() await db.end(); // for example, a pg Pool process.exit(0); }); server.closeIdleConnections(); // Node 18.2+: don't wait on idle keep-alive sockets }, 5000); // Safety net: never hang forever on a stuck request setTimeout(() =&gt; process.exit(1), 25000).unref(); });Notes: From Node 19, server.close() already closes idle keep-alive connections. Calling closeIdleConnections() after it is harmless and covers Node 18.2 and later. Whatever starts and stops my containers has to wait long enough. Docker waits 10 seconds by default after SIGTERM before sending SIGKILL, so I raise stop_grace_period (in Compose) above my safety-net timeout, otherwise the shutdown code never gets to finish. I start Node in the container with the exec form, CMD [\"node\", \"server.js\"], not npm start and not the shell form CMD node server.js. In both of those, a wrapper process (npm or /bin/sh) becomes PID 1, docker stop signals only PID 1, and the wrapper may never pass SIGTERM on, so my handler never runs. Here's the sequence I'm aiming for: sequenceDiagram participant D as Deploy tool participant S as App server participant LB as Load balancer D-&gt;&gt;S: SIGTERM S-&gt;&gt;S: /healthz starts returning 503 LB-&gt;&gt;S: health check S--&gt;&gt;LB: 503 draining Note over LB: Stops sending new requests S-&gt;&gt;S: Finish in-flight requests S-&gt;&gt;S: Close connections and exit 0 Note over D,S: If still running after the grace period, SIGKILLThat sequence assumes a load balancer that runs active health checks, such as managed load balancers, HAProxy, or NGINX Plus. Open-source Nginx only notices a failing server passively, after real requests have already failed, so the 503 from /healthz doesn't help there. That's one more reason my deploy scripts drain a server at the load balancer explicitly before stopping it. Graceful shutdown is the second layer of protection, not the only one. 2. Two health endpoints I use the same split as in my scaling post: /healthz is shallow and is what the load balancer polls. /readyz checks the database and Redis (and also returns 503 while draining), and my deploy script waits on it before putting a server back in rotation. The load balancer's check must not depend on shared services, or a database blip pulls every server out at once. 3. Backward-compatible migrations During a deploy, old and new code run side by side against the same database. The rule I follow: every release must work with the previous release's schema, and the previous release must work with this release's schema. Change Safe in a single release? How I do it Add a nullable column Yes Add it, then deploy code that uses it Add an index Yes, if it doesn't block writes In Postgres, CREATE INDEX CONCURRENTLY. It can't run inside a transaction block, so that migration has to run without one Rename or drop a column No Expand and contract over several releases Add a NOT NULL constraint No Backfill first, add the constraint in a later release Change a column's type No New column, backfill, switch reads, drop the old one later Two more habits: Run migrations once, as their own step, before any app server updates. Never from every server's startup script, or three servers race each other. The destructive \"contract\" step ships in a later release, after the new version has been stable for a while. 4. Immutable, versioned builds Every build gets tagged with the git commit SHA, and the exact same image moves through every environment. I never deploy latest, because I can't tell what that means or roll back to it. I also expose the version so I can see which server handled a request: app.use((req, res, next) =&gt; { res.set(\"X-App-Version\", process.env.APP_VERSION || \"dev\"); next(); });I also add the version to my logs and metrics. It matters most for canaries, where I compare old and new side by side. 5. Static assets that outlive the deploy If a page rendered by v2 asks for app.3f9a1c.js and the request lands on a v1 server that doesn't have it, that's a 404 in the middle of a deploy. The reverse happens too. So I use fingerprinted file names and serve assets from a CDN or object storage, where old and new files coexist. I delete old assets only well after the rollout is done. The three strategies at a glance flowchart LR subgraph CAN[\"Canary: expose v2 to a small slice first\"] direction TB CLB[Load balancer] -- \"90%\" --&gt; STABLE[\"Stable servers&lt;br/&gt;v1\"] CLB -- \"10%\" --&gt; CANARY[\"Canary server&lt;br/&gt;v2\"] end subgraph BG[\"Blue-green: flip between two environments\"] direction TB BLB[Load balancer] -- \"100% of traffic\" --&gt; BLUE[\"Blue&lt;br/&gt;v1, live\"] BLB -. \"0%, deployed and tested\" .-&gt; GREEN[\"Green&lt;br/&gt;v2, idle\"] end subgraph ROLLING[\"Rolling: replace servers one by one\"] direction TB RLB[Load balancer] --&gt; R1[\"Server 1&lt;br/&gt;v2, updated\"] RLB -. \"draining\" .-&gt; R2[\"Server 2&lt;br/&gt;v1, being updated\"] RLB --&gt; R3[\"Server 3&lt;br/&gt;v1\"] endAnd here is roughly how much of my traffic is served by the new version at each step of a deploy: Start Step 1 Step 2 Step 3 Done Rolling (3 servers) 0% 0% (server 1 updating) ~50% 100% (server 3 updating) 100% Blue-green 0% 0% (green deployed and tested) 100% (the flip) 100% (blue kept for rollback) 100% (blue retired) Canary 0% 5% 25% 50% 100% With only three servers, rolling is chunky: by the time the last server is being updated, every request is already hitting v2. With more servers the ramp gets smoother. Strategy 1: Rolling deployment How it works: I replace servers one at a time (or in small batches). Each one is drained, updated, checked, and put back before I touch the next. Step Server 1 Server 2 Server 3 Serving capacity 0 v1 v1 v1 3 of 3 1 updating v1 v1 2 of 3 2 v2 updating v1 2 of 3 3 v2 v2 updating 2 of 3 4 v2 v2 v2 3 of 3 Notice the capacity dip. During the roll I'm running on two servers instead of three, so I need enough headroom to survive that (the \"N+1\" rule), or I add a temporary extra server first. My rolling deploy script (a sketch) lb.sh is a placeholder for my own small wrapper around the load balancer. With open-source Nginx it would mark a server down in the upstream and reload. With a managed load balancer it would call the provider's API (AWS calls the drain period the \"deregistration delay\", for example). Swap in whatever your setup uses. #!/usr/bin/env bash # deploy-rolling.sh &lt;git-sha&gt; # Assumes compose.yml tags the image with ${APP_VERSION} set -euo pipefail VERSION=\"$1\" SERVERS=(\"10.0.1.11\" \"10.0.1.12\" \"10.0.1.13\") wait_ready() { # poll /readyz: 30 tries, 2 seconds apart for _ in $(seq 1 30); do if curl -fsS --max-time 2 \"http://$1:3000/readyz\" &gt; /dev/null; then return 0 fi sleep 2 done return 1 } for host in \"${SERVERS[@]}\"; do echo \"==&gt; $host: draining\" ./lb.sh drain \"$host\" # stop new traffic, let in-flight requests finish echo \"==&gt; $host: deploying $VERSION\" ssh \"$host\" \"APP_VERSION=$VERSION docker compose -f /srv/zyvop/compose.yml up -d --pull always\" if wait_ready \"$host\"; then ./lb.sh enable \"$host\" echo \"==&gt; $host: back in rotation\" else echo \"!! $host failed its readiness check. Leaving it out of rotation and stopping.\" exit 1 # servers not yet updated keep running the old version fi done echo \"Deploy of $VERSION complete\"The most important line is exit 1. If anything looks wrong, the deploy stops, the untouched servers keep serving the old version, and I'm looking at one broken server instead of three. A half-finished deploy does leave a mixed fleet, running both versions until I fix forward or roll back, which is exactly why the compatibility rules above matter. Rolling: what I like and what I watch for Cheapest option, with no extra infrastructure. Simple to reason about and easy to script. Two versions are live at once for the duration of the roll, so migrations and assets must be compatible (see the groundwork above). Capacity dips while a server is out. Rollback means running another rolling deploy with the previous version, which takes as long as the original one. If I were on Kubernetes Deployments do rolling updates by default. These two settings give the \"surge first, never drop capacity\" behavior, and the readiness probe is what keeps traffic away from a pod that isn't ready: spec: replicas: 3 # the pod template also needs a readinessProbe on /readyz (not shown) strategy: type: RollingUpdate rollingUpdate: maxSurge: 1 # start one extra pod before removing an old one maxUnavailable: 0 # never go below full capacityStrategy 2: Blue-green deployment How it works: I keep two complete environments. Blue is live. I deploy the new version to green while blue keeps serving everyone, test green directly, then switch the load balancer to green in one move. Blue stays up as an instant rollback. sequenceDiagram participant U as Visitors participant LB as Load balancer participant B as Blue v1 live participant G as Green v2 idle Note over B,G: 1. Deploy v2 to green while blue serves everyone U-&gt;&gt;LB: requests LB-&gt;&gt;B: 100% of traffic Note over G: 2. Run smoke tests directly against green Note over LB: 3. Flip the load balancer to green U-&gt;&gt;LB: requests LB-&gt;&gt;G: 100% of traffic Note over B: 4. Keep blue running as the instant rollback Note over LB,B: Rollback means flipping the load balancer back to blueHow I flip with Nginx The upstream pulls its servers from a file, and that file is a symlink to either the blue or the green list: # /etc/nginx/conf.d/zyvop.conf upstream zyvop_app { include /etc/nginx/zyvop/active.conf; # symlink to blue.conf or green.conf }# /etc/nginx/zyvop/blue.conf server 10.0.1.11:3000; server 10.0.1.12:3000;# /etc/nginx/zyvop/green.conf server 10.0.2.11:3000; server 10.0.2.12:3000;I keep blue.conf, green.conf and active.conf out of conf.d/ and any other directory my main config globs with include. Otherwise Nginx tries to load them at the top (http) level, where a bare server host:port; line isn't valid, and refuses to start or reload. Before the flip, I test green directly, bypassing the load balancer: curl -fsS http://10.0.2.11:3000/readyz curl -fsS -D - -o /dev/null http://10.0.2.11:3000/ | grep -i x-app-versionThen the flip, and the rollback, are the same command pointed at different files: sudo ln -sfn /etc/nginx/zyvop/green.conf /etc/nginx/zyvop/active.conf sudo nginx -t &amp;&amp; sudo nginx -s reloadnginx -t checks the config first, so a typo never takes the site down. The reload is graceful: new worker processes use the new config while old workers finish the requests they already have. Blue-green: what I like and what I watch for Instant, low-drama rollback. Point the symlink back at blue and reload. I can test the real thing before anyone sees it. Green runs in a production-like environment with production-like config. New traffic goes to one version only after the flip (long-lived connections aside, see below). Things that bite: Cost. I run two full environments for the duration of the deploy. In the cloud, I can create green on demand and destroy blue afterwards. That's much easier with infrastructure as code. The database is shared, so it doesn't roll back. Flipping back to blue gets the old code back, not the old data. Migrations still have to be compatible with both versions. Warm up green first. A cold green taking 100% of traffic instantly can be slow. I send it some synthetic requests before the flip. Schedulers and cron must run in only one environment. Otherwise I get the duplicate-job problem from my scaling post (Step 6), or no jobs at all during the switch. Sessions and caches are shared (Redis), so whatever v1 writes, v2 must be able to read, and the other way around. Long-lived connections stay on blue. After an Nginx reload, the old workers keep existing connections (WebSockets, streams) open until they close, so those clients stay on v1 and I can't retire blue until they drain. I can cut them off with worker_shutdown_timeout, but then they drop. Either way, clients need reconnect logic. I don't use DNS for the flip. DNS answers get cached, so some visitors keep hitting blue for minutes or longer. A load balancer flip is immediate. Strategy 3: Canary deployment How it works: The new version goes to a small slice of real traffic first (the \"canary\", like the bird in the coal mine). I compare its health with the stable version, and only ramp up if it holds. If it misbehaves, I send the canary back to 0% and only a few visitors were affected. flowchart TD D[Deploy v2 to canary servers] --&gt; S1[Send 5% of traffic to the canary] S1 --&gt; W[Watch for 10 to 15 minutes] W --&gt; OK{\"Canary as healthy as stable?\"} OK -- Yes --&gt; N{\"More steps left?\"} N -- Yes --&gt; UP[\"Raise the share: 25%, then 50%, then 100%\"] UP --&gt; W N -- No --&gt; DONE[v2 is at 100%, retire v1] OK -- No --&gt; AB[Set canary to 0% and investigate]How I split traffic with Nginx split_clients hashes a key from each request and sends a percentage of the hash space to one upstream and the rest to another: upstream zyvop_stable { server 10.0.1.11:3000; server 10.0.1.12:3000; } upstream zyvop_canary { server 10.0.1.21:3000; } # Hash the client so the same visitor keeps landing on the same side split_clients \"${remote_addr}${http_user_agent}\" $zyvop_pool { 5% zyvop_canary; * zyvop_stable; } server { listen 443 ssl; server_name zyvop.com www.zyvop.com; # ssl_certificate lines and proxy_set_header lines as in my main config location / { proxy_pass http://$zyvop_pool; # the variable resolves to an upstream group name } }Some details worth knowing: Because the hash space is carved up in order, raising 5% to 25% keeps the original 5% of visitors on the canary. Nobody flips back and forth between versions as I ramp up. Hashing IP plus user agent is a rough key. People behind the same NAT move together, and mobile users' IPs change. If zyvop.com has logins, I'd hash a stable user ID or cookie instead. The same goes if a CDN or another proxy sits in front of Nginx, because then $remote_addr is that proxy's address, not the visitor's. In open-source Nginx, each ramp step is a config edit and a reload. NGINX Plus can change the ratio without a reload by keeping it in its key-value store and updating it through the API, with the config choosing between preset splits. Many managed load balancers support weights as well, such as weighted target groups on AWS (where I'd turn on target group stickiness so a visitor stays on one side) or weighted pools on Cloudflare (where session affinity, if enabled, takes precedence over the weights). I check the provider's current docs. What I watch during a canary I compare the canary against the stable version at the same time, not against yesterday: Error rate (5xx responses) Latency (p95 and p99, not just the average) Saturation (CPU, memory, database connections) Application errors in the logs, split by X-App-Version Business metrics (signups, checkouts, whatever matters on zyvop.com) I decide the abort rule before I start. A reasonable starting point: abort if the canary's 5xx rate is more than double stable's, or its p95 latency is 25% worse, for five minutes in a row. I tune those numbers over time. Canary: what I like and what I watch for Smallest blast radius. A bad release hurts a few percent of visitors instead of all of them. Real traffic is the best test. It catches problems that staging never will. It needs enough traffic to mean anything. If zyvop.com gets 200 requests a minute, a 5% canary sees only 10. Even a 10% error rate there is one failed request a minute, which is easy to miss. For low-traffic sites, a canary mostly adds ceremony. Two versions live for longer, so compatibility rules matter even more. More tooling. Per-version metrics, alerts, and ideally automated analysis. On Kubernetes, tools like Argo Rollouts and Flagger can ramp and abort canaries automatically based on metrics. Side by side Rolling Blue-green Canary How traffic moves Server by server All at once Gradually, in steps Extra infrastructure None (N+1 headroom helps) A second full environment A few canary servers plus a way to split traffic Rollback speed Slow (another rolling deploy) Instant (flip back) Fast (set canary to 0%) Blast radius of a bad release Grows as the roll proceeds, unless I stop early Everyone at the flip, but undo is instant Small (the canary slice) Two versions live at once Yes, during the roll Mostly no, after the flip Yes, for the whole soak Database compatibility needed Yes Yes Yes Complexity Low Medium High Best for Everyday releases Risky or big releases, major upgrades High-traffic sites and behavior changes Which one I use flowchart TD Q[New release ready] --&gt; R{\"Is it risky? Big migration, major dependency upgrade, or a core flow rewrite\"} R -- No --&gt; ROLL[\"Rolling deploy&lt;br/&gt;my default\"] R -- Yes --&gt; T{\"Enough traffic to measure a small slice?\"} T -- Yes --&gt; CAN[\"Canary&lt;br/&gt;start at 5%, then ramp up\"] T -- No --&gt; BG{\"Can I afford a second environment for a short time?\"} BG -- Yes --&gt; BLUEGREEN[\"Blue-green&lt;br/&gt;test green, flip, keep blue\"] BG -- No --&gt; SLOW[\"Rolling, one server at a time&lt;br/&gt;with extra manual checks&lt;br/&gt;and a feature flag\"]My plan for zyvop.com, in order: Start with rolling, plus graceful shutdown, health checks, and backward-compatible migrations. That alone gets me to zero dropped requests for everyday releases. Add blue-green once I can spin up a second environment from code in minutes, and use it for the scary releases. Add canary only when traffic and monitoring are good enough that a 5% slice actually tells me something. These aren't mutually exclusive. A common combination is blue-green environments with a weighted ramp between them, which is a canary at the environment level. Rollbacks, feature flags, and the database Decide the rollback criteria before I deploy, not while I'm staring at a broken dashboard. Write them in the release notes or runbook. Practice the rollback. A rollback I've never run is a rollback I don't trust. The database is the part that doesn't roll back. That's why destructive migrations ship separately and later, after the new version has proven itself. Feature flags separate deploying from releasing. I can ship code turned off, then enable it for a few users, then everyone. Turning a risky behavior off becomes a config change instead of a deploy. They work with all three strategies. I just keep them short-lived and delete them once a feature is fully out. Mistakes I'm trying not to make No graceful shutdown. Every deploy quietly drops requests. A load balancer that doesn't know a server is draining. Traffic reaches a server that's about to stop. Running migrations from every server's startup. Three servers race each other. Shipping a destructive migration in the same release as the code change. No safe way back. Asset 404s mid-deploy. Old HTML pointing at files that no longer exist, or the reverse. Forgetting about cron and schedulers in green or canary environments. Duplicate jobs, or none at all. Using DNS for the cutover. Cached answers send some visitors to the old version. A canary with too little traffic to learn anything. Deploying without rollback criteria. Never practicing a rollback. My zero-downtime deploy checklist The app handles SIGTERM: drains, finishes in-flight requests, then exits The container stop grace period is longer than my shutdown timeout /healthz returns 503 while draining, and /readyz checks dependencies Builds are immutable and tagged with the git SHA, never latest The app exposes its version (X-App-Version), and logs and metrics include it Migrations run once, before the deploy, and are backward compatible Static assets are fingerprinted and served from a CDN, old and new side by side Only one scheduler runs per environment at any time The deploy script stops on the first failed readiness check Rollback criteria are written down, and I've practiced the rollback Alerts watch 5xx rate, latency, and saturation during a deploy Risky behavior ships behind a feature flag Final thoughts Zero-downtime deploys aren't about picking the fanciest strategy. They come from small, boring habits: draining servers before stopping them, never running two versions that disagree about the database, and always having a fast way back. The three strategies are different dials on how much safety I buy and how much it costs. For zyvop.com, I'm starting with rolling and earning my way up to blue-green and canary as the site grows. The next step is to run all of this from a CI/CD pipeline, so a deploy is a merge instead of a ritual. Which strategy do you use for your own site, and have you ever been bitten by a deploy? Tell me in the comments and I'll cover it in a follow-up.","contentHash":"sha256:4134f31b0467b0eacc4141864fcd5bf403dd577dd5d35fc7df477fd25c01d447","authorName":"Sanju Singh","authorUrl":"https://zyvop.com/author/sanjay687","authorSameAs":[],"category":"DevOps","tags":["blue-green deployment","canary release","Zero Downtime","rolling deployment","DevOps"],"audience":"Senior software engineers, systems architects, and technical leads working with DevOps","tone":"Instructional, practical, code-first","readingTimeMinutes":16,"wordCount":4139,"faqs":null,"primaryTopic":"DevOps","publishedAt":"2026-11-21T03:35:29.768Z","updatedAt":"2026-11-21T03:35:29.768Z","canonicalUrl":"https://zyvop.com/how-i-deploy-zyvop-com-with-zero-downtime-rolling-vs-blue-green-vs-canary-kk9qi"}