---
title: "Fly"
description: "36 posts about Fly, summarised, each linking to the original."
---

# Fly
> 36 posts about Fly, summarised, each linking to the original.

## Articles

### [Hugo's There - Flying with Hugo and Caddy](https://yomu.fyi/post/hugo-s-there-flying-with-hugo-and-caddy.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jul 21, 2020
- Type: Tutorial

A new community venture’s website is built with Hugo, served by Caddy, and deployed on Fly, with a custom makeroni.cc domain added after the initial deployment. The process initializes a Fly app on port 80, uses Hugo’s Quickstart and Ananke theme, and employs a multi-stage Docker build based on klakegg/hugo:0.74.0-onbuild, copying generated files into caddy:2.1.1. Caddy serves the static files with file\_server while auto\_https is disabled because Fly handles certificate management; separate rules serve makeroni.cc and redirect the old fly.dev hostname. DNS A and AAAA records connect the domain to Fly, and flyctl certs create requests a Let’s Encrypt certificate through DNS validation, leaving the site ready to serve securely after redeployment.


### [Flyctl meets JSON](https://yomu.fyi/post/flyctl-meets-json.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jun 23, 2020
- Type: Announcement

Flyctl adds a --json, or -j, flag that presents command output as JSON to support automation around Fly applications. For GraphQL-backed commands it emits the API data, while logs become structured JSON and deployment progress arrives as a stream of Source/Status/Message objects. The post demonstrates piping flyctl list apps --json through jq to filter fields, convert hostnames and statuses to CSV, and select undeployed apps whose names feed xargs flyctl info --json -a; jq -s then gathers the resulting objects into an array. Because deployment output currently mixes JSON with non-JSON messages, the post recommends using --detach and polling flyctl status or running flyctl monitor instead of relying on the JSON stream for deployment monitoring.


### [Fly Changelog for 29th May](https://yomu.fyi/post/fly-changelog-for-29th-may.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: May 29, 2020
- Type: Announcement

This Fly Changelog records significant changes to the Fly platform, tooling, and websites for the week of 29 May 2020. flyctl 0.0.124 adds apps pause and apps resume commands, which remove all running instances or start one running instance, respectively; regions set replaces the regions in a region pool list; and -v/--verbose provides more detailed command output. The release also improves flyctl apps list by displaying each application's status, while the Deno Buildpack supports unstable Deno builds when an .unstable directory is added to the application directory. Earlier in the month, flyctl 0.0.123 introduced open, which finds a deployed application's hostname and instructs a web browser to open it.


### [Fly - Now With Power Pause](https://yomu.fyi/post/fly-now-with-power-pause.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: May 28, 2020
- Type: Announcement

Fly introduces Power Pause, a way to mothball applications when development pauses, schedules slip, or running costs need management. The new flyctl suspend command saves an application's state and reduces its running instances to zero while retaining networking configuration, IP addresses, and certificates; flyctl resume restores service by starting one instance first, even for applications deployed across multiple regions. Operators can then use flyctl scale set min=n to increase the minimum count, while flyctl regions list shows the region pool and the new regions set command replaces manual region additions and deletions. The release also adds application status to account listings and a flyctl open command that opens a deployed application's hostname in a browser.


### [Deno on Fly](https://yomu.fyi/post/deno-on-fly.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: May 14, 2020
- Type: Tutorial

Deno on Fly explains how to package and deploy a Deno 1.0 application using a Dockerfile rather than a buildpack. The example uses the hellodeno-dockerfile project, with an Alpine Linux and Deno 1.0.0 base image, port 8080, a non-root deno user, and separate dependency and application caching layers. A deps.ts file pins imported package versions, while the Dockerfile runs deno cache deps.ts and deno cache server.ts before starting server.ts with deno run --allow-net server.ts. After local Docker testing, the deployment flow uses flyctl init to create the Fly app and fly.toml, then flyctl deploy to build and push the image. The resulting application is available at a Fly hostname, with HTTP and TLS routing to port 8080, automatic HTTPS redirection, and the option to scale globally and add domains with generated certificates.


### [Fly Changelog 1st May 2020](https://yomu.fyi/post/fly-changelog-1st-may-2020.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: May 1, 2020
- Type: Announcement

Fly’s 1 May 2020 changelog records enhancements to flyctl, a new Open Source page, and a revised load-balancing allocation algorithm. Version 0.0.117 added flyctl auth docker, allowing deployments of images directly to Fly by adding registry.fly.io to Docker’s authenticated registries, and introduced --image-label for selecting a specific image label at deployment time. The release also increased the timeout at the end of deployment monitoring to prevent erroneous “No Deployment” messages and changed deploy version negotiation to resolve API compatibility errors. For global applications with large numbers of instances, the new algorithm directs each incoming connection to an instance from the closest least-loaded service among three randomly selected healthy services in the app’s three nearest regions.


### [Imaginary on Fly, just One-click](https://yomu.fyi/post/imaginary-on-fly-just-one-click.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Apr 20, 2020
- Type: Announcement

Fly announces a one-click launcher for Imaginary, an open-source image service that is among Fly’s popular global image-service use cases. The launcher is intended to let users create a running, production-ready version without infrastructure by pasting button code, and Imaginary’s creators added it to the project’s GitHub README. The post says users can get started with operations including converting and resizing images faster, while scalable SVG buttons are designed to work on pages. It also presents one-click launchers as a possible funding channel through revenue sharing and invites other open-source projects to help develop a process for launching applications on Fly.


### [Fly Changelog 17th April 2020](https://yomu.fyi/post/fly-changelog-17th-april-2020.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Apr 17, 2020
- Type: Announcement

This changelog records updates to Fly’s infrastructure, flyctl tooling, and web experience during the week ending 17 April 2020. Version 0.0.116 improves diagnostics for invalid fly.toml files by listing problematic sections and settings, adds Homebrew upgrade instructions to the README, provides basic names for flyctl scale vm sizes, and packages flyctl for Arch Linux through flyctl-bin. On the platform, new applications receive their app.fly.dev certificate “instantly,” while Fly Proxy can serve replacement certificates two weeks before expiration when possible. The site also adds a dedicated ChangeLog page that consolidates recent entries, alongside an RSS feed containing changelog posts. The flyctl changes include contributions from Lars Lehtonen and Simon Willison.


### [Powerbuilding with Fly](https://yomu.fyi/post/powerbuilding-with-fly.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Apr 8, 2020
- Type: Tutorial

Powerbuilding with Fly explains how flyctl controls Docker-image builds when deploying applications to Fly infrastructure. It covers selecting the application configuration with --config, choosing an alternate Dockerfile with --dockerfile, and passing build-time values through --build-args. Using NGINX\_PORT as an example, the post shows how Docker ARG can receive a default or command-line value and how ENV=${NGINX\_PORT} carries that value into the running image; flyctl deploy --build-args NGINX\_PORT=4000 overrides 8080. Build arguments are intended for non-sensitive data because values are baked into the image and may be retrievable, while Fly Secrets are recommended for sensitive application data and are injected as environment variables when the image starts.


### [Making Datasets Fly with Datasette and Fly](https://yomu.fyi/post/making-datasets-fly-with-datasette-and-fly.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Mar 26, 2020
- Type: Tutorial

Datasette makes SQLite datasets accessible through a web interface, with SQL queries, JSON and CSV export, and a REST/JSON API. This tutorial imports New York Central Park Squirrel Census CSV data into SQLite, runs it locally with Datasette, and publishes the database to Fly using the datasette-publish-fly plugin. It then renames the database’s X and Y columns to Longitude and Latitude, installs datasette-cluster-map, and redeploys with the plugin to produce an interactive map of squirrel sightings. The deployments expose Datasette online at Fly hostnames, with HTTPS, automatically generated Let’s Encrypt certificates, custom domain support, global deployment options, and edge networking with SSL termination. The mapped deployment lets users inspect individual sightings and view their details.


### [Continuous Deployment with GitLab](https://yomu.fyi/post/continuous-deployment-with-gitlab.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Mar 23, 2020
- Type: Tutorial

The guide shows how to set up continuous deployment from GitLab CI/CD to a Fly application, using the small Go hellofly example. GitLab supplies the repository contents to a Runner defined by the golang:1.13 image, while a before\_script installs curl and downloads flyctl through Fly’s installation script. A deploy job then runs flyctl deploy, which builds and deploys the application from a committed fly.toml file. Authentication is configured by obtaining a token with flyctl auth token and storing it as a protected, masked FLY\_API\_TOKEN CI/CD variable in the repository settings. After .gitlab-ci.yml is committed and pushed, GitLab starts the deployment job, while the guide notes that more advanced pipeline structures and triggers remain available.


### [Fly Answers Questions](https://yomu.fyi/post/fly-answers-questions.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Mar 18, 2020
- Type: Explainer

Fly Answers Questions compiles responses about custom domains, configuration recovery, Turboku deployment, database latency, TLS termination, global databases, continuous deployment, and idle-app scaling. Fly allows multiple custom hostnames per application and automatically provisions Let’s Encrypt certificates after validation; a deleted fly.toml can be restored with flyctl config save -a , with -c supporting another filename. For Turboku, Heroku slugs run as containers in a nearby datacenter rather than at the edge, while region selection can reduce database latency and retain edge SSL termination. The service supports TLS-only termination up to HTTP/1.1, GitHub Actions deployment, Redis for local caching, and a replication system for distributing changes, while keeping one running instance for idle apps instead of scaling them to zero.


### [How to do Custom Domains with Fly](https://yomu.fyi/post/how-to-do-custom-domains-with-fly.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Mar 9, 2020
- Type: Tutorial

Custom Domains with Fly is an application guide for using Fly to proxy traffic or serve applications across multiple custom domains. It explains how to configure an NGINX server for external sites and how to attach host and domain names to Fly applications with the flyctl command line. For automated workflows, it describes the Fly GraphQL API operations for adding, removing, checking, and deleting hosts and associated certificates, and points to a repository of ready-rolled Node applications demonstrating the API. The guide's speed run retrieves an app's IPv4 and IPv6 addresses, adds corresponding A and AAAA DNS records, creates a certificate with flyctl, and uses another command to monitor issuance. The resulting setup provides auto-renewing Let's Encrypt TLS certificates, edge TLS, and HTTP/2 support; the guide also states that Fly applications have no limit on attached certificates and can scale on demand.


### [GraphQL, Hasura and Fly](https://yomu.fyi/post/graphql-hasura-and-fly.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Feb 25, 2020
- Type: Tutorial

Hasura provides an open source GraphQL backend for accessing PostgreSQL, mapping database schemas and roles to simplify queries. It can also query other GraphQL services, allowing multiple services to be combined, and includes an interactive console for analysis and exploration. The post presents deploying Hasura on Fly using its Docker image to create a global GraphQL backend, with configuration required for the database location, secrets, and interactive-console availability. It points to a published deployment guide that walks through those steps and frames Fly as a simpler way to run Hasura, while directing readers to Fly Docs and a hands-on path for deploying a first app.


### [Fly Friday - Flyctl and Ports](https://yomu.fyi/post/fly-friday-flyctl-and-ports.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Feb 14, 2020
- Type: Announcement

Flyctl adds a new -p option to flyctl apps create, allowing users to set an app’s internal port during initial creation. The numeric value is written to the generated fly.toml configuration, replacing the default port of 8080. This addresses workflows using prebuilt Docker images, where users may not control the port and previously had to create the app, edit fly.toml, and change the internal port manually. Available from Flyctl release 0.94, the flag removes that edit and is shown in the first Fly Friday video. The post defines the internal port as the port an application uses to communicate with the world, while the command-line setting supplies that value before deployment configuration is generated.


### [Command Lines, Flyctl and Fly](https://yomu.fyi/post/command-lines-flyctl-and-fly.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jan 29, 2020
- Type: Announcement

Fly presents the Fly Global Application Platform as a command-line-first service and introduces flyctl as the way to sign up for free and manage an application's entire lifecycle. The post argues that command-line interfaces integrate directly with modern workflows, are simple and expressive, and keep developers in their terminal and current directory. To replace its Node-based command-line technology, Fly built flyctl in Go as self-contained binaries for macOS, Linux, and Windows, and adopted Cobra for familiar command/subcommand behavior and contextual help. Web interfaces remain intended for rich dashboards and metric displays, alongside interactive terminal use. The command-line approach also makes instructions self-contained, scriptable, and repeatable, which the post identifies as valuable for support and operations, while the open GitHub repository invites feedback.


[Newer posts](https://yomu.fyi/topic/fly.md)