| 1 | --- |
| 2 | title: Container images |
| 3 | description: Push and pull container images on g1t.sh with docker, in workflows with G1T_TOKEN, and push layers over 100 MB with g1t push. |
| 4 | --- |
| 5 | |
| 6 | g1t.sh is a container registry. Images are named after their workspace, |
| 7 | pushed and pulled with `docker` or any client of the OCI Distribution |
| 8 | protocol, and have the access of the repository they are linked to (see |
| 9 | [who can see and publish a package](/guides/packages/#who-can-see-and-publish-a-package)). |
| 10 | |
| 11 | ```text |
| 12 | g1t.sh/<workspace>/<name>[:<tag>] |
| 13 | ``` |
| 14 | |
| 15 | ## Sign in |
| 16 | |
| 17 | Use your username, and an [access token](https://g1t.sh/settings/tokens) as |
| 18 | the password: one with full access, or with `packages:write` (to push) or |
| 19 | `packages:read` (to pull private images). |
| 20 | |
| 21 | ```sh |
| 22 | echo "$G1T_TOKEN" | docker login g1t.sh -u <you> --password-stdin |
| 23 | ``` |
| 24 | |
| 25 | Public images pull without signing in. |
| 26 | |
| 27 | ## Push |
| 28 | |
| 29 | Tag the image with its address and push it: |
| 30 | |
| 31 | ```sh |
| 32 | docker build -t g1t.sh/acme/web:1.4.0 . |
| 33 | docker push g1t.sh/acme/web:1.4.0 |
| 34 | ``` |
| 35 | |
| 36 | The first push makes the package. When its name starts with a repository |
| 37 | of the workspace, here `acme/web`, it is linked to that repository and |
| 38 | follows its visibility and roles; pushing needs Write on it. Otherwise it is |
| 39 | the workspace's, private, and needs the workspace's Write base permission. |
| 40 | |
| 41 | Pushing a tag again moves it to the new image. Layers already on g1t are |
| 42 | not uploaded again, and images in the same workspace share them. |
| 43 | |
| 44 | Multi-platform images (`docker buildx build --platform linux/amd64,linux/arm64 --push`), |
| 45 | OCI image indexes, and artifacts attached to an image with a `subject` |
| 46 | (signatures, SBOMs, attestations) are all kept; the registry lists an image's |
| 47 | attached artifacts at `/v2/<name>/referrers/<digest>`. |
| 48 | |
| 49 | ## Pull |
| 50 | |
| 51 | ```sh |
| 52 | docker pull g1t.sh/acme/web:1.4.0 |
| 53 | docker pull g1t.sh/acme/web@sha256:… |
| 54 | ``` |
| 55 | |
| 56 | ## In workflows |
| 57 | |
| 58 | A workflow's `G1T_TOKEN`, [the job's own token](/guides/actions/#the-jobs-token), can pull the workspace's images, and |
| 59 | push them with `packages: write` in its [`permissions:`](/guides/actions/#the-jobs-token): |
| 60 | |
| 61 | ```yaml |
| 62 | jobs: |
| 63 | image: |
| 64 | runs-on: ubuntu-latest |
| 65 | permissions: |
| 66 | contents: read |
| 67 | packages: write |
| 68 | steps: |
| 69 | - uses: actions/checkout@v4 |
| 70 | - name: Sign in to g1t.sh |
| 71 | run: echo "${{ secrets.G1T_TOKEN }}" | docker login g1t.sh -u g1t --password-stdin |
| 72 | - name: Build and push |
| 73 | run: | |
| 74 | docker build -t g1t.sh/${{ github.repository }}:${{ github.sha }} . |
| 75 | docker push g1t.sh/${{ github.repository }}:${{ github.sha }} |
| 76 | ``` |
| 77 | |
| 78 | On g1t's own machines a job is already signed in to g1t.sh with that |
| 79 | token when it starts, so the sign-in step can be left out there; it does |
| 80 | no harm. Pushing needs `packages: write` in the job's |
| 81 | [`permissions:`](/guides/actions/#the-jobs-token); pulling needs only the |
| 82 | default `packages: read`. Runs that get no secrets (a pull request from |
| 83 | someone without Write) get a token that only reads: they pull, and cannot |
| 84 | push. See |
| 85 | [secrets and variables](/guides/actions/#secrets-and-variables). |
| 86 | |
| 87 | ## The 100 MB limit |
| 88 | |
| 89 | A single request to g1t.sh may carry at most 100 MB. `docker push` sends |
| 90 | each layer whole, in one request, so a layer over 100 MB, as compressed for |
| 91 | the push, is refused. [`g1t push`](#push-large-layers-with-g1t-push) sends |
| 92 | it in chunks instead, and has no limit. |
| 93 | |
| 94 | What you see depends on where it is refused. Usually it is before the |
| 95 | request reaches g1t, and `docker push` stops with a bare status: |
| 96 | |
| 97 | ```text |
| 98 | unknown: failed commit on ref "layer-sha256:…": unexpected status from PUT request to https://g1t.sh/v2/acme/web/blobs/uploads/…?digest=sha256%3A…: 413 Request Entity Too Large |
| 99 | ``` |
| 100 | |
| 101 | (the request may be a `PATCH` instead of a `PUT`, and some versions of |
| 102 | Docker show the HTML page that came with the 413 instead). When g1t sees |
| 103 | the request itself, the error is `SIZE_INVALID`, with a message naming the |
| 104 | limit and this page. |
| 105 | |
| 106 | An installation you [run yourself](/guides/self-hosting/) has no such |
| 107 | limit. |
| 108 | |
| 109 | ### Push large layers with g1t push |
| 110 | |
| 111 | `g1t push` takes an image from your local docker and pushes it to g1t.sh, |
| 112 | each layer in chunks of 90 MiB, each chunk its own request. A layer can be |
| 113 | any size. |
| 114 | |
| 115 | ```sh |
| 116 | docker build -t g1t.sh/acme/model:1 . |
| 117 | g1t push g1t.sh/acme/model:1 |
| 118 | ``` |
| 119 | |
| 120 | An image with a local name is pushed to the address after `--as`: |
| 121 | |
| 122 | ```sh |
| 123 | g1t push model:dev --as g1t.sh/acme/model:1 |
| 124 | ``` |
| 125 | |
| 126 | ```text |
| 127 | Reading model:dev from docker |
| 128 | Pushing to g1t.sh/acme/model:1 |
| 129 | config sha256:040e744c070b 851 B already on the registry, skipped |
| 130 | layer sha256:25f1d6b1951a 3.5 MiB already on the registry, skipped |
| 131 | chunk 1/2 90.0 MiB 63% |
| 132 | chunk 2/2 53.1 MiB 100% |
| 133 | layer sha256:c74595c4a2cd 143.1 MiB uploaded in 2 chunks |
| 134 | Pushed g1t.sh/acme/model:1 |
| 135 | digest: sha256:39b972d91774d58b5fbd27cfdce73fe58034d9e5772a261d183c11bcf78c1dba |
| 136 | ``` |
| 137 | |
| 138 | It pushes the image docker has: the same config, layers and manifest, so |
| 139 | `docker pull` gets back exactly what you built. When docker keeps a layer |
| 140 | uncompressed, `g1t push` gzips it for the push, as `docker push` does. |
| 141 | Layers already on g1t are not sent again. A request refused with `429` or |
| 142 | an error on g1t's side is tried again after a wait, and an interrupted |
| 143 | layer goes on from where it stopped. |
| 144 | |
| 145 | It signs in with the first of: |
| 146 | |
| 147 | 1. a token on stdin, with `--token-stdin` |
| 148 | (`echo "$G1T_TOKEN" | g1t push … --token-stdin`); |
| 149 | 2. the `G1T_TOKEN` environment variable, as in [workflows](#in-workflows); |
| 150 | 3. what `docker login g1t.sh` stored, in `~/.docker/config.json` or the |
| 151 | credential store it names. |
| 152 | |
| 153 | | Option | | |
| 154 | | --- | --- | |
| 155 | | `--as <address>` | Where to push, `g1t.sh/<workspace>/<name>:<tag>`. Without it, the image's own name must be such an address. The tag defaults to `latest`. | |
| 156 | | `--chunk-size <size>` | How much each request carries: `5MB` to `95MB`, `90MB` unless set. `MB` and `MiB` both mean 1,048,576 bytes. | |
| 157 | | `--token-stdin` | Read the token from stdin. | |
| 158 | | `--archive <file>` | Push a tarball written by `docker save`, instead of asking docker. Needs `--as`. | |
| 159 | |
| 160 | `g1t --version` prints its version, and `g1t help` its options. |
| 161 | |
| 162 | ### Getting g1t |
| 163 | |
| 164 | One file for each platform, from `https://g1t.sh/downloads/cli/latest/`: |
| 165 | |
| 166 | ```sh |
| 167 | # Linux (x64; use g1t-linux-arm64 on ARM) |
| 168 | curl -fsSLo g1t https://g1t.sh/downloads/cli/latest/g1t-linux-x64 && chmod +x g1t |
| 169 | # macOS (Apple silicon; use g1t-macos-x64 on Intel) |
| 170 | curl -fsSLo g1t https://g1t.sh/downloads/cli/latest/g1t-macos-arm64 && chmod +x g1t |
| 171 | ``` |
| 172 | |
| 173 | ```powershell |
| 174 | # Windows |
| 175 | Invoke-WebRequest https://g1t.sh/downloads/cli/latest/g1t-windows-x64.exe -OutFile g1t.exe |
| 176 | ``` |
| 177 | |
| 178 | Check a download against `https://g1t.sh/downloads/cli/latest/SHA256SUMS`. |
| 179 | To build it from source instead, with |
| 180 | [Rust](https://www.rust-lang.org/tools/install): |
| 181 | |
| 182 | ```sh |
| 183 | git clone https://g1t.sh/flagon-io/g1t |
| 184 | cd g1t |
| 185 | cargo install --path crates/g1t |
| 186 | ``` |
| 187 | |
| 188 | ## Storage and pull limits |
| 189 | |
| 190 | Without the [g1t plan](/guides/usage-and-billing/#the-g1t-plan), a |
| 191 | workspace's public packages may hold 10 GB and its private ones 500 MB, |
| 192 | each file counted once. A push that would go past either is refused with |
| 193 | `DENIED` and a message saying how much is used; layers the workspace |
| 194 | already holds add nothing. On the plan nothing is refused: storage past |
| 195 | the free amounts is charged. |
| 196 | |
| 197 | Anonymous pulls are limited to 300 requests a minute from each address, and |
| 198 | signed-in ones to 5,000 a minute for each person, workspace or agent. |
| 199 | Past the limit, requests are answered `429` with `TOOMANYREQUESTS` and a |
| 200 | `Retry-After`; docker waits and tries again. Signing in raises the limit. |
| 201 | |
| 202 | ## Delete |
| 203 | |
| 204 | Deleting needs Admin on the linked repository, or for an unlinked image, an |
| 205 | owner of the workspace; a token needs `packages:delete`. |
| 206 | |
| 207 | The registry protocol's `DELETE` removes a tag, or a whole version by its |
| 208 | digest (with every tag that points to it): |
| 209 | |
| 210 | ```sh |
| 211 | TOKEN=$(curl -s -u <you>:<token> "https://g1t.sh/v2/token?scope=repository:acme/web:delete" | jq -r .token) |
| 212 | curl -X DELETE -H "Authorization: Bearer $TOKEN" https://g1t.sh/v2/acme/web/manifests/1.4.0 |
| 213 | curl -X DELETE -H "Authorization: Bearer $TOKEN" https://g1t.sh/v2/acme/web/manifests/sha256:… |
| 214 | ``` |
| 215 | |
| 216 | Layers no version uses any more are deleted from storage a day later. |
| 217 | |
| 218 | ## Errors |
| 219 | |
| 220 | | Error | Means | |
| 221 | | --- | --- | |
| 222 | | `UNAUTHORIZED` | Not signed in, or the token is wrong or expired. `docker login g1t.sh` again. | |
| 223 | | `DENIED` | Signed in, but your role or your token's scopes do not allow it. The message says which. | |
| 224 | | `NAME_UNKNOWN` | No such image, or one you cannot see. | |
| 225 | | `MANIFEST_UNKNOWN`, `BLOB_UNKNOWN` | No such tag, digest or layer in that image. | |
| 226 | | `NAME_INVALID` | Names are lowercase letters and digits, separated by `.`, `_`, `__`, `-` or `/`, and start with a workspace. | |
| 227 | | `SIZE_INVALID`, or a bare `413` | A request over [the 100 MB limit](#the-100-mb-limit). Push the image with [`g1t push`](#push-large-layers-with-g1t-push). | |
| 228 | | `TOOMANYREQUESTS` | Too many requests in a minute; see [the limits](#storage-and-pull-limits). | |
| 229 | | `DIGEST_INVALID` | What was uploaded does not have the digest the client said. Push again. | |