diff --git a/docker-buildx/0.14.0/.brew/docker-buildx.rb b/docker-buildx/0.14.0/.brew/docker-buildx.rb new file mode 100644 index 0000000..c68cfc1 --- /dev/null +++ b/docker-buildx/0.14.0/.brew/docker-buildx.rb @@ -0,0 +1,41 @@ +class DockerBuildx < Formula + desc "Docker CLI plugin for extended build capabilities with BuildKit" + homepage "https://docs.docker.com/buildx/working-with-buildx/" + url "https://github.com/docker/buildx/archive/refs/tags/v0.14.0.tar.gz" + sha256 "9ed27d47b728288500ba2535366792d9b006354e02178688360919663f92b63e" + license "Apache-2.0" + head "https://github.com/docker/buildx.git", branch: "master" + + depends_on "go" => :build + + def install + ldflags = %W[ + -s -w + -X github.com/docker/buildx/version.Version=v#{version} + -X github.com/docker/buildx/version.Revision=#{tap.user} + ] + + system "go", "build", *std_go_args(ldflags:), "./cmd/buildx" + + (lib/"docker/cli-plugins").install_symlink bin/"docker-buildx" + + doc.install Dir["docs/reference/*.md"] + + generate_completions_from_executable(bin/"docker-buildx", "completion") + end + + def caveats + <<~EOS + docker-buildx is a Docker plugin. For Docker to find the plugin, add "cliPluginsExtraDirs" to ~/.docker/config.json: + "cliPluginsExtraDirs": [ + "#{HOMEBREW_PREFIX}/lib/docker/cli-plugins" + ] + EOS + end + + test do + assert_match "github.com/docker/buildx v#{version}", shell_output("#{bin}/docker-buildx version") + output = shell_output(bin/"docker-buildx build . 2>&1", 1) + assert_match(/(denied while trying to|Cannot) connect to the Docker daemon/, output) + end +end diff --git a/docker-buildx/0.14.0/docker-buildx-0.14.0-Unraid.txz b/docker-buildx/0.14.0/docker-buildx-0.14.0-Unraid.txz new file mode 100644 index 0000000..8ebb73c Binary files /dev/null and b/docker-buildx/0.14.0/docker-buildx-0.14.0-Unraid.txz differ diff --git a/docker-buildx/LICENSE b/docker-buildx/LICENSE new file mode 100755 index 0000000..d645695 --- /dev/null +++ b/docker-buildx/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/docker-buildx/README.md b/docker-buildx/README.md new file mode 100755 index 0000000..e1d8ac5 --- /dev/null +++ b/docker-buildx/README.md @@ -0,0 +1,317 @@ +# buildx + +[![GitHub release](https://img.shields.io/github/release/docker/buildx.svg?style=flat-square)](https://github.com/docker/buildx/releases/latest) +[![PkgGoDev](https://img.shields.io/badge/go.dev-docs-007d9c?style=flat-square&logo=go&logoColor=white)](https://pkg.go.dev/github.com/docker/buildx) +[![Build Status](https://img.shields.io/github/actions/workflow/status/docker/buildx/build.yml?branch=master&label=build&logo=github&style=flat-square)](https://github.com/docker/buildx/actions?query=workflow%3Abuild) +[![Go Report Card](https://goreportcard.com/badge/github.com/docker/buildx?style=flat-square)](https://goreportcard.com/report/github.com/docker/buildx) +[![codecov](https://img.shields.io/codecov/c/github/docker/buildx?logo=codecov&style=flat-square)](https://codecov.io/gh/docker/buildx) + +`buildx` is a Docker CLI plugin for extended build capabilities with +[BuildKit](https://github.com/moby/buildkit). + +Key features: + +- Familiar UI from `docker build` +- Full BuildKit capabilities with container driver +- Multiple builder instance support +- Multi-node builds for cross-platform images +- Compose build support +- High-level build constructs (`bake`) +- In-container driver support (both Docker and Kubernetes) + +# Table of Contents + +- [Installing](#installing) + - [Windows and macOS](#windows-and-macos) + - [Linux packages](#linux-packages) + - [Manual download](#manual-download) + - [Dockerfile](#dockerfile) +- [Set buildx as the default builder](#set-buildx-as-the-default-builder) +- [Building](#building) +- [Getting started](#getting-started) + - [Building with buildx](#building-with-buildx) + - [Working with builder instances](#working-with-builder-instances) + - [Building multi-platform images](#building-multi-platform-images) +- [Reference](docs/reference/buildx.md) + - [`buildx bake`](docs/reference/buildx_bake.md) + - [`buildx build`](docs/reference/buildx_build.md) + - [`buildx create`](docs/reference/buildx_create.md) + - [`buildx du`](docs/reference/buildx_du.md) + - [`buildx imagetools`](docs/reference/buildx_imagetools.md) + - [`buildx imagetools create`](docs/reference/buildx_imagetools_create.md) + - [`buildx imagetools inspect`](docs/reference/buildx_imagetools_inspect.md) + - [`buildx inspect`](docs/reference/buildx_inspect.md) + - [`buildx ls`](docs/reference/buildx_ls.md) + - [`buildx prune`](docs/reference/buildx_prune.md) + - [`buildx rm`](docs/reference/buildx_rm.md) + - [`buildx stop`](docs/reference/buildx_stop.md) + - [`buildx use`](docs/reference/buildx_use.md) + - [`buildx version`](docs/reference/buildx_version.md) +- [Contributing](#contributing) + +For more information on how to use Buildx, see +[Docker Build docs](https://docs.docker.com/build/). + +# Installing + +Using `buildx` with Docker requires Docker engine 19.03 or newer. + +> **Warning** +> +> Using an incompatible version of Docker may result in unexpected behavior, +> and will likely cause issues, especially when using Buildx builders with more +> recent versions of BuildKit. + +## Windows and macOS + +Docker Buildx is included in [Docker Desktop](https://docs.docker.com/desktop/) +for Windows and macOS. + +## Linux packages + +Docker Engine package repositories contain Docker Buildx packages when installed according to the +[Docker Engine install documentation](https://docs.docker.com/engine/install/). Install the +`docker-buildx-plugin` package to install the Buildx plugin. + +## Manual download + +> **Important** +> +> This section is for unattended installation of the buildx component. These +> instructions are mostly suitable for testing purposes. We do not recommend +> installing buildx using manual download in production environments as they +> will not be updated automatically with security updates. +> +> On Windows and macOS, we recommend that you install [Docker Desktop](https://docs.docker.com/desktop/) +> instead. For Linux, we recommend that you follow the [instructions specific for your distribution](#linux-packages). + +You can also download the latest binary from the [GitHub releases page](https://github.com/docker/buildx/releases/latest). + +Rename the relevant binary and copy it to the destination matching your OS: + +| OS | Binary name | Destination folder | +| -------- | -------------------- | -----------------------------------------| +| Linux | `docker-buildx` | `$HOME/.docker/cli-plugins` | +| macOS | `docker-buildx` | `$HOME/.docker/cli-plugins` | +| Windows | `docker-buildx.exe` | `%USERPROFILE%\.docker\cli-plugins` | + +Or copy it into one of these folders for installing it system-wide. + +On Unix environments: + +* `/usr/local/lib/docker/cli-plugins` OR `/usr/local/libexec/docker/cli-plugins` +* `/usr/lib/docker/cli-plugins` OR `/usr/libexec/docker/cli-plugins` + +On Windows: + +* `C:\ProgramData\Docker\cli-plugins` +* `C:\Program Files\Docker\cli-plugins` + +> **Note** +> +> On Unix environments, it may also be necessary to make it executable with `chmod +x`: +> ```shell +> $ chmod +x ~/.docker/cli-plugins/docker-buildx +> ``` + +## Dockerfile + +Here is how to install and use Buildx inside a Dockerfile through the +[`docker/buildx-bin`](https://hub.docker.com/r/docker/buildx-bin) image: + +```dockerfile +# syntax=docker/dockerfile:1 +FROM docker +COPY --from=docker/buildx-bin /buildx /usr/libexec/docker/cli-plugins/docker-buildx +RUN docker buildx version +``` + +# Set buildx as the default builder + +Running the command [`docker buildx install`](docs/reference/buildx_install.md) +sets up docker builder command as an alias to `docker buildx build`. This +results in the ability to have `docker build` use the current buildx builder. + +To remove this alias, run [`docker buildx uninstall`](docs/reference/buildx_uninstall.md). + +# Building + +```console +# Buildx 0.6+ +$ docker buildx bake "https://github.com/docker/buildx.git" +$ mkdir -p ~/.docker/cli-plugins +$ mv ./bin/build/buildx ~/.docker/cli-plugins/docker-buildx + +# Docker 19.03+ +$ DOCKER_BUILDKIT=1 docker build --platform=local -o . "https://github.com/docker/buildx.git" +$ mkdir -p ~/.docker/cli-plugins +$ mv buildx ~/.docker/cli-plugins/docker-buildx + +# Local +$ git clone https://github.com/docker/buildx.git && cd buildx +$ make install +``` + +# Getting started + +## Building with buildx + +Buildx is a Docker CLI plugin that extends the `docker build` command with the +full support of the features provided by [Moby BuildKit](https://github.com/moby/buildkit) +builder toolkit. It provides the same user experience as `docker build` with +many new features like creating scoped builder instances and building against +multiple nodes concurrently. + +After installation, buildx can be accessed through the `docker buildx` command +with Docker 19.03. `docker buildx build` is the command for starting a new +build. With Docker versions older than 19.03 buildx binary can be called +directly to access the `docker buildx` subcommands. + +```console +$ docker buildx build . +[+] Building 8.4s (23/32) + => ... +``` + +Buildx will always build using the BuildKit engine and does not require +`DOCKER_BUILDKIT=1` environment variable for starting builds. + +The `docker buildx build` command supports features available for `docker build`, +including features such as outputs configuration, inline build caching, and +specifying target platform. In addition, Buildx also supports new features that +are not yet available for regular `docker build` like building manifest lists, +distributed caching, and exporting build results to OCI image tarballs. + +Buildx is flexible and can be run in different configurations that are exposed +through various "drivers". Each driver defines how and where a build should +run, and have different feature sets. + +We currently support the following drivers: +- The `docker` driver ([guide](docs/manuals/drivers/docker.md), [reference](https://docs.docker.com/engine/reference/commandline/buildx_create/#driver)) +- The `docker-container` driver ([guide](docs/manuals/drivers/docker-container.md), [reference](https://docs.docker.com/engine/reference/commandline/buildx_create/#driver)) +- The `kubernetes` driver ([guide](docs/manuals/drivers/kubernetes.md), [reference](https://docs.docker.com/engine/reference/commandline/buildx_create/#driver)) +- The `remote` driver ([guide](docs/manuals/drivers/remote.md)) + +For more information on drivers, see the [drivers guide](docs/manuals/drivers/index.md). + +## Working with builder instances + +By default, buildx will initially use the `docker` driver if it is supported, +providing a very similar user experience to the native `docker build`. Note that +you must use a local shared daemon to build your applications. + +Buildx allows you to create new instances of isolated builders. This can be +used for getting a scoped environment for your CI builds that does not change +the state of the shared daemon or for isolating the builds for different +projects. You can create a new instance for a set of remote nodes, forming a +build farm, and quickly switch between them. + +You can create new instances using the [`docker buildx create`](docs/reference/buildx_create.md) +command. This creates a new builder instance with a single node based on your +current configuration. + +To use a remote node you can specify the `DOCKER_HOST` or the remote context name +while creating the new builder. After creating a new instance, you can manage its +lifecycle using the [`docker buildx inspect`](docs/reference/buildx_inspect.md), +[`docker buildx stop`](docs/reference/buildx_stop.md), and +[`docker buildx rm`](docs/reference/buildx_rm.md) commands. To list all +available builders, use [`buildx ls`](docs/reference/buildx_ls.md). After +creating a new builder you can also append new nodes to it. + +To switch between different builders, use [`docker buildx use `](docs/reference/buildx_use.md). +After running this command, the build commands will automatically use this +builder. + +Docker also features a [`docker context`](https://docs.docker.com/engine/reference/commandline/context/) +command that can be used for giving names for remote Docker API endpoints. +Buildx integrates with `docker context` so that all of your contexts +automatically get a default builder instance. While creating a new builder +instance or when adding a node to it you can also set the context name as the +target. + +## Building multi-platform images + +BuildKit is designed to work well for building for multiple platforms and not +only for the architecture and operating system that the user invoking the build +happens to run. + +When you invoke a build, you can set the `--platform` flag to specify the target +platform for the build output, (for example, `linux/amd64`, `linux/arm64`, or +`darwin/amd64`). + +When the current builder instance is backed by the `docker-container` or +`kubernetes` driver, you can specify multiple platforms together. In this case, +it builds a manifest list which contains images for all specified architectures. +When you use this image in [`docker run`](https://docs.docker.com/engine/reference/commandline/run/) +or [`docker service`](https://docs.docker.com/engine/reference/commandline/service/), +Docker picks the correct image based on the node's platform. + +You can build multi-platform images using three different strategies that are +supported by Buildx and Dockerfiles: + +1. Using the QEMU emulation support in the kernel +2. Building on multiple native nodes using the same builder instance +3. Using a stage in Dockerfile to cross-compile to different architectures + +QEMU is the easiest way to get started if your node already supports it (for +example. if you are using Docker Desktop). It requires no changes to your +Dockerfile and BuildKit automatically detects the secondary architectures that +are available. When BuildKit needs to run a binary for a different architecture, +it automatically loads it through a binary registered in the `binfmt_misc` +handler. + +For QEMU binaries registered with `binfmt_misc` on the host OS to work +transparently inside containers they must be registered with the `fix_binary` +flag. This requires a kernel >= 4.8 and binfmt-support >= 2.1.7. You can check +for proper registration by checking if `F` is among the flags in +`/proc/sys/fs/binfmt_misc/qemu-*`. While Docker Desktop comes preconfigured +with `binfmt_misc` support for additional platforms, for other installations +it likely needs to be installed using [`tonistiigi/binfmt`](https://github.com/tonistiigi/binfmt) +image. + +```console +$ docker run --privileged --rm tonistiigi/binfmt --install all +``` + +Using multiple native nodes provide better support for more complicated cases +that are not handled by QEMU and generally have better performance. You can +add additional nodes to the builder instance using the `--append` flag. + +Assuming contexts `node-amd64` and `node-arm64` exist in `docker context ls`; + +```console +$ docker buildx create --use --name mybuild node-amd64 +mybuild +$ docker buildx create --append --name mybuild node-arm64 +$ docker buildx build --platform linux/amd64,linux/arm64 . +``` + +Finally, depending on your project, the language that you use may have good +support for cross-compilation. In that case, multi-stage builds in Dockerfiles +can be effectively used to build binaries for the platform specified with +`--platform` using the native architecture of the build node. A list of build +arguments like `BUILDPLATFORM` and `TARGETPLATFORM` is available automatically +inside your Dockerfile and can be leveraged by the processes running as part +of your build. + +```dockerfile +# syntax=docker/dockerfile:1 +FROM --platform=$BUILDPLATFORM golang:alpine AS build +ARG TARGETPLATFORM +ARG BUILDPLATFORM +RUN echo "I am running on $BUILDPLATFORM, building for $TARGETPLATFORM" > /log +FROM alpine +COPY --from=build /log /log +``` + +You can also use [`tonistiigi/xx`](https://github.com/tonistiigi/xx) Dockerfile +cross-compilation helpers for more advanced use-cases. + +## High-level build options + +See [High-level builds with Bake](https://docs.docker.com/build/bake/) for more details. + +# Contributing + +Want to contribute to Buildx? Awesome! You can find information about +contributing to this project in the [CONTRIBUTING.md](/.github/CONTRIBUTING.md) diff --git a/utilities/whereis/whereis-Unraid.txz-Unraid.txz b/utilities/whereis/whereis-Unraid.txz similarity index 100% rename from utilities/whereis/whereis-Unraid.txz-Unraid.txz rename to utilities/whereis/whereis-Unraid.txz