docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ENGDOCS-2078 (#19927) 

* ENGDOCS-2078

* edits

* edits

* SME review edits

* Apply suggestions from code review

Co-authored-by: Craig Osterhout <103533812+craig-osterhout@users.noreply.github.com>

* Update content/compose/bridge/_index.md

Co-authored-by: Usha Mandya <47779042+usha-mandya@users.noreply.github.com>

---------

Co-authored-by: Craig Osterhout <103533812+craig-osterhout@users.noreply.github.com>
Co-authored-by: Usha Mandya <47779042+usha-mandya@users.noreply.github.com>
This commit is contained in:
Allie Sadler 2024-07-26 10:39:10 +01:00 committed by GitHub
parent 6660884722
commit 6abe8e647d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 346 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
content/compose/bridge/_index.md
View File

@ -1,189 +1,42 @@
---
description: Overview of Docker Compose Bridge
description: Understand what Compose Bridge is and how it can be useful
keywords: compose, orchestration, kubernetes, bridge
title: Overview of Docker Compose Bridge
title: Overview of Compose Bridge
---
{{< include "compose-bridge-early-access.md" >}}
## Introduction
Compose Bridge lets you transform your Compose configuration file into configuration files for different platforms, primarily focusing on Kubernetes. The default transformation generates Kubernetes manifests and a Kustomize overlay which are designed for deployment on Docker Desktop with Kubernetes enabled.
Docker Compose makes it easy to define a multi-container application
to be run on a single-node Docker Engine, relying on a `compose.yaml` file to
describe resources with a simple abstraction.
It's a flexible tool that lets you either take advantage of the [default transformation](usage.md) or [create a custom transformation](customize.md) to suit specific project needs and requirements.
Compose Bridge lets you reuse this exact same `compose.yaml` file but
translate it into another platform's definition format, with a primary
focus on Kubernetes. This transformation can be customized to match
specific needs and requirements.
Compose Bridge significantly simplifies the transition from Docker Compose to Kubernetes, making it easier for you to leverage the power of Kubernetes while maintaining the simplicity and efficiency of Docker Compose.
## Usage
## How it works
Compose Bridge is a command line tool that consumes a `compose.yaml` file
and runs a transformation to produce resource definitions for another platform.
[By default](transformation.md), it produces Kubernetes manifests and a Kustomize overlay for Docker Desktop. For example:
```console
$ compose-bridge -f compose.yaml convert
Kubernetes resource api-deployment.yaml created
Kubernetes resource db-deployment.yaml created
Kubernetes resource web-deployment.yaml created
Kubernetes resource api-expose.yaml created
Kubernetes resource db-expose.yaml created
Kubernetes resource web-expose.yaml created
Kubernetes resource 0-avatars-namespace.yaml created
Kubernetes resource default-network-policy.yaml created
Kubernetes resource private-network-policy.yaml created
Kubernetes resource public-network-policy.yaml created
Kubernetes resource db-db_data-persistentVolumeClaim.yaml created
Kubernetes resource api-service.yaml created
Kubernetes resource web-service.yaml created
Kubernetes resource kustomization.yaml created
Kubernetes resource db-db_data-persistentVolumeClaim.yaml created
Kubernetes resource api-service.yaml created
Kubernetes resource web-service.yaml created
Kubernetes resource kustomization.yaml created
```
Compose Bridge uses transformations to let you convert a Compose model into another form.
Such manifests can then be used to run the application on Kubernetes using
the standard deployment command `kubectl apply -k out/overlays/desktop/`.
A transformation is packaged as a Docker image that receives the fully resolved Compose model as `/in/compose.yaml` and can produce any target format file under `/out`.
## Customization
Compose Bridge provides its own transformation for Kubernetes using Go templates, so that it is easy to extend for customization by replacing or appending your own templates.
The Kubernetes manifests produced by Compose Bridge
are designed to allow deployment on Docker Desktop with Kubernetes enabled.
For more detailed information on how these transformations work and how you can customize them for your projects, see [Customize](customize.md).
Kubernetes is such a versatile platform that there are many ways
to map Compose concepts into a Kubernetes resource definitions. Compose
Bridge lets you customize the transformation to match your own infrastructure
decisions and preferences, with various level of flexibility / investment.
## Setup
To get started with Compose Bridge, you need to:
### Modify the default templates
1. Download and install a version of Docker Desktop that supports Compose Bridge.
2. Sign in to your Docker account.
3. Navigate to the **Features in development** tab in **Settings**.
4. From the **Experimental features** tab, select **Enable Compose Bridge**.
You can extract templates used by default transformation `docker/compose-bridge-kubernetes`
by running `compose-bridge transformations create my-template --from docker/compose-bridge-kubernetes`
and adjusting those to match your needs.
## Feedback
The templates will be extracted into a directory named after your template name (ie `my-template`).
Inside, you will find a Dockerfile that allows you to create your own image to distribute your template, as well as a directory containing the templating files.
You are free to edit the existing files, delete them, or [add new ones](#add-your-own-templates) to subsequently generate Kubernetes manifests that meet your needs.
You can then use the generated Dockerfile to package your changes into a new Transformer image, which you can then use with Compose Bridge:
To give feedback, report bugs, or receive support, email `desktop-preview@docker.com`. There is also a dedicated Slack channel. To join, simply send an email to the provided address.
```console
$ docker build --tag mycompany/transform --push .
```
## What's next?
You can then use your transformation as a replacement:
```console
$ compose-bridge -f compose.yaml convert --transformation mycompany/transform
```
For more information, see [Templates](./templates.md).
### Add your own templates
For resources that are not managed by Compose Bridge's default transformation,
you can build your own templates. The `compose.yaml` model may not offer all
the configuration attributes required to populate the target manifest. If this is the case, you can
then rely on Compose custom extensions to let developers better describe the
application, and offer an agnostic transformation.
As an illustration, if developers add `x-virtual-host` metadata
to service definitions in the `compose.yaml` file, you can use the following custom attribute
to produce Ingress rules:
```yaml
{{ $project := .name }}
#! {{ $name }}-ingress.yaml
# Generated code, do not edit
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: virtual-host-ingress
namespace: {{ $project }}
spec:
rules:
{{ range $name, $service := .services }}
{{ if $service.x-virtual-host }}
- host: ${{ $service.x-virtual-host }}
http:
paths:
- path: "/"
backend:
service:
name: ${{ name }}
port:
number: 80
{{ end }}
{{ end }}
```
Once packaged into a Docker image, you can use this custom template
when transforming Compose models into Kubernetes in addition to other
transformations:
```console
$ compose-bridge -f compose.yaml convert \
--transformation docker/compose-bridge-kubernetes \
--transformation mycompany/transform
```
### Build your own transformation
While Compose Bridge templates make it easy to customize with minimal changes,
you may want to make significant changes, or rely on an existing conversion tool.
A Compose Bridge transformation is a Docker image that is designed to get a Compose model
from `/in/compose.yaml` and produce platform manifests under `/out`. This simple
contract makes it easy to bundle an alternate transformation, as illustrated below using
[Kompose](https://kompose.io/):
```Dockerfile
FROM alpine
# Get kompose from github release page
RUN apk add --no-cache curl
ARG VERSION=1.32.0
RUN ARCH=$(uname -m | sed 's/armv7l/arm/g' | sed 's/aarch64/arm64/g' | sed 's/x86_64/amd64/g') && \
curl -fsL \
"https://github.com/kubernetes/kompose/releases/download/v${VERSION}/kompose-linux-${ARCH}" \
-o /usr/bin/kompose
RUN chmod +x /usr/bin/kompose
CMD ["/usr/bin/kompose", "convert", "-f", "/in/compose.yaml", "--out", "/out"]
```
This Dockerfile bundles Kompose and defines the command to run this tool according
to the Compose Bridge transformation contract.
## Use `compose-bridge` as a `kubectl` plugin
To use the `compose-bridge` binary as a `kubectl` plugin, you need to make sure that the binary is available in your PATH and the name of the binary is prefixed with `kubectl-`.
1. Rename or copy the `compose-bridge` binary to `kubectl-compose_bridge`:
```console
$ mv /path/to/compose-bridge /usr/local/bin/kubectl-compose_bridge
```
2. Ensure that the binary is executable:
```console
$ chmod +x /usr/local/bin/kubectl-compose_bridge
```
3. Verify that the plugin is recognized by `kubectl`:
```console
$ kubectl plugin list
```
In the output, you should see `kubectl-compose_bridge`.
4. Now you can use `compose-bridge` as a `kubectl` plugin:
```console
$ kubectl compose-bridge [command]
```
Replace `[command]` with any `compose-bridge` command you want to use.
- [Use Compose Bridge](usage.md)
- [Explore how you can customize Compose Bridge](customize.md)
- [Explore the advanced integration](advanced-integration.md)

41
content/compose/bridge/advanced-integration.md Normal file
View File

@ -0,0 +1,41 @@
---
title: Advanced integration
description: Learn about how Compose Bridge can function a kubectl plugin
keywords: kubernetes, compose, compose bridge, plugin, advanced
---
{{< include "compose-bridge-early-access.md" >}}
Compose Bridge can also function as a `kubectl` plugin, allowing you to integrate its capabilities directly into your Kubernetes command-line operations. This integration simplifies the process of converting and deploying applications from Docker Compose to Kubernetes.
## Use `compose-bridge` as a `kubectl` plugin
To use the `compose-bridge` binary as a `kubectl` plugin, you need to make sure that the binary is available in your PATH and the name of the binary is prefixed with `kubectl-`.
1. Rename or copy the `compose-bridge` binary to `kubectl-compose_bridge`:
```console
$ mv /path/to/compose-bridge /usr/local/bin/kubectl-compose_bridge
```
2. Ensure that the binary is executable:
```console
$ chmod +x /usr/local/bin/kubectl-compose_bridge
```
3. Verify that the plugin is recognized by `kubectl`:
```console
$ kubectl plugin list
```
In the output, you should see `kubectl-compose_bridge`.
4. Now you can use `compose-bridge` as a `kubectl` plugin:
```console
$ kubectl compose-bridge [command]
```
Replace `[command]` with any `compose-bridge` command you want to use.

188
content/compose/bridge/customize.md Normal file
View File

@ -0,0 +1,188 @@
---
title: Customize Compose Bridge
description: Learn about the Compose Bridge templates syntax
keywords: compose, bridge, templates
---
{{< include "compose-bridge-early-access.md" >}}
This page explains how Compose Bridge utilizes templating to efficiently translate Docker Compose files into Kubernetes manifests. It also explain how you can customize these templates for your specific requirements and needs, or how you can build your own transformation.
## How it works
Compose bridge uses transformations to let you convert a Compose model into another form.
A transformation is packaged as a Docker image that receives the fully-resolved Compose model as `/in/compose.yaml` and can produce any target format file under `/out`.
Compose Bridge provides its transformation for Kubernetes using Go templates, so that it is easy to extend for customization by just replacing or appending your own templates.
### Syntax
Compose Bridge make use of templates to transform a Compose configuration file into Kubernetes manifests. Templates are plain text files that use the [Go templating syntax](https://pkg.go.dev/text/template). This enables the insertion of logic and data, making the templates dynamic and adaptable according to the Compose model.
When a template is executed, it must produce a YAML file which is the standard format for Kubernetes manifests. Multiple files can be generated as long as they are separated by `---`
Each YAML output file begins with custom header notation, for example:
```yaml
#! manifest.yaml
```
In the following example, a template iterates over services defined in a `compose.yaml` file. For each service, a dedicated Kubernetes manifest file is generated, named according to the service and containing specified configurations.
```yaml
{{ range $name, $service := .services }}
---
#! {{ $name }}-manifest.yaml
# Generated code, do not edit
key: value
## ...
{{ end }}
```
### Input
The input Compose model is the canonical YAML model you can get by running `docker compose config`. Within the templates, data from the `compose.yaml` is accessed using dot notation, allowing you to navigate through nested data structures. For example, to access the deployment mode of a service, you would use `service.deploy.mode`:
```yaml
# iterate over a yaml sequence
{{ range $name, $service := .services }}
# access a nested attribute using dot notation
{{ if eq $service.deploy.mode "global" }}
kind: DaemonSet
{{ end }}
{{ end }}
```
You can check the [Compose Specification JSON schema](https://github.com/compose-spec/compose-go/blob/main/schema/compose-spec.json) to have a full overview of the Compose model. This schema outlines all possible configurations and their data types in the Compose model.
### Helpers
As part of the Go templating syntax, Compose Bridge offers a set of YAML helper functions designed to manipulate data within the templates efficiently:
- `seconds`: Converts a [duration](https://github.com/compose-spec/compose-spec/blob/master/11-extension.md#specifying-durations) into an integer
- `uppercase`: Converts a string into upper case characters
- `title`: Converts a string by capitalizing the first letter of each word
- `safe`: Converts a string into a safe identifier, replacing all characters (except lowercase a-z) with `-`
- `truncate`: Removes the N first elements from a list
- `join`: Groups elements from a list into a single string, using a separator
- `base64`: Encodes a string as base64 used in Kubernetes for encoding secrets
- `map`: Transforms a value according to mappings expressed as `"value -> newValue"` strings
- `indent`: Writes string content indented by N spaces
- `helmValue`: Writes the string content as a template value in the final file
In the following example, the template checks if a healthcheck interval is specified for a service, applies the `seconds` function to convert this interval into seconds and assigns the value to the `periodSeconds` attribute.
```yaml
{{ if $service.healthcheck.interval }}
periodSeconds: {{ $service.healthcheck.interval | seconds }}{{ end }}
{{ end }}
```
## Customization
As Kubernetes is a versatile platform, there are many ways
to map Compose concepts into Kubernetes resource definitions. Compose
Bridge lets you customize the transformation to match your own infrastructure
decisions and preferences, with various level of flexibility and effort.
### Modify the default templates
You can extract templates used by the default transformation `docker/compose-bridge-kubernetes`,
by running `compose-bridge transformations create --from docker/compose-bridge-kubernetes my-template`
and adjusting the templates to match your needs.
The templates are extracted into a directory named after your template name, in this case `my-template`.
It includes a Dockerfile that lets you create your own image to distribute your template, as well as a directory containing the templating files.
You are free to edit the existing files, delete them, or [add new ones](#add-your-own-templates) to subsequently generate Kubernetes manifests that meet your needs.
You can then use the generated Dockerfile to package your changes into a new transformation image, which you can then use with Compose Bridge:
```console
$ docker build --tag mycompany/transform --push .
```
You can then use your transformation as a replacement:
```console
$ compose-bridge convert --transformations mycompany/transform
```
### Add your own templates
For resources that are not managed by Compose Bridge's default transformation,
you can build your own templates. The `compose.yaml` model may not offer all
the configuration attributes required to populate the target manifest. If this is the case, you can
then rely on Compose custom extensions to better describe the
application, and offer an agnostic transformation.
For example, if you add `x-virtual-host` metadata
to service definitions in the `compose.yaml` file, you can use the following custom attribute
to produce Ingress rules:
```yaml
{{ $project := .name }}
#! {{ $name }}-ingress.yaml
# Generated code, do not edit
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: virtual-host-ingress
namespace: {{ $project }}
spec:
rules:
{{ range $name, $service := .services }}
{{ if $service.x-virtual-host }}
- host: ${{ $service.x-virtual-host }}
http:
paths:
- path: "/"
backend:
service:
name: ${{ name }}
port:
number: 80
{{ end }}
{{ end }}
```
Once packaged into a Docker image, you can use this custom template
when transforming Compose models into Kubernetes in addition to other
transformations:
```console
$ compose-bridge convert \
--transformation docker/compose-bridge-kubernetes \
--transformation mycompany/transform
```
### Build your own transformation
While Compose Bridge templates make it easy to customize with minimal changes,
you may want to make significant changes, or rely on an existing conversion tool.
A Compose Bridge transformation is a Docker image that is designed to get a Compose model
from `/in/compose.yaml` and produce platform manifests under `/out`. This simple
contract makes it easy to bundle an alternate transformation using
[Kompose](https://kompose.io/):
```Dockerfile
FROM alpine
# Get kompose from github release page
RUN apk add --no-cache curl
ARG VERSION=1.32.0
RUN ARCH=$(uname -m | sed 's/armv7l/arm/g' | sed 's/aarch64/arm64/g' | sed 's/x86_64/amd64/g') && \
curl -fsL \
"https://github.com/kubernetes/kompose/releases/download/v${VERSION}/kompose-linux-${ARCH}" \
-o /usr/bin/kompose
RUN chmod +x /usr/bin/kompose
CMD ["/usr/bin/kompose", "convert", "-f", "/in/compose.yaml", "--out", "/out"]
```
This Dockerfile bundles Kompose and defines the command to run this tool according
to the Compose Bridge transformation contract.
## What's next?
- [Explore the advanced integration](advanced-integration.md)

74
content/compose/bridge/templates.md
View File

@ -1,74 +0,0 @@
---
title: Compose Bridge templates
description: Learn about the Compose Bridge templates syntax
keywords: compose, bridge, templates
---
{{< include "compose-bridge-early-access.md" >}}
Compose Bridge's default transformation uses templates to produce Kubernetes manifests.
This page describes the templating mechanism.
## Syntax
Templates are plain text files, using [go-template](https://pkg.go.dev/text/template)
to allow logic and data injection based on the `compose.yaml` model.
When a template is executed, it must produce a YAML file. Multiple files can be generated
as long as those are separated by `---`
The first line, when creating the YAML file, defines the file being generated using a custom notation:
```yaml
#! manifest.yaml
```
With this header comment, `manifest.yaml` will be created by Compose Bridge with the content following
the annotation.
Combining these together, you can write a template to iterate over some of Compose resources,
then for each resource you can produce a dedicated manifest:
```yaml
{{ range $name, $service := .services }}
---
#! {{ $name }}-manifest.yaml
# Generated code, do not edit
key: value
## ...
{{ end }}
```
This example produces a manifest file for each and every Compose service in you Compose model.
## Input
The input compose model is the canonical yaml model you can get by running
`docker compose config`. Within a template you can access model nodes using
dot notation:
```yaml
# iterate over a yaml sequence
{{ range $name, $service := .services }}
# access a nested attribute using dot notation
{{ if eq $service.deploy.mode "global" }}
kind: DaemonSet
{{ end }}
{{ end }}
```
You can check the [Compose Specification json-spec file](https://github.com/compose-spec/compose-go/blob/main/schema/compose-spec.json) to have a full overview of the Compose model.
## Helpers
As part of the Go templating syntax, Compose Bridge offers a set of helper functions:
- `seconds`: convert a [duration](https://github.com/compose-spec/compose-spec/blob/master/11-extension.md#specifying-durations) into an integer
- `uppercase` convert a string into upper case characters
- `title`: convert a string by capitalizing first letter of each word
- `safe`: convert a string into a safe identifier, replacing all characters but \[a-z\] with `-`
- `truncate`: removes the N first elements from a list
- `join`: group elements from a list into a single string, using a separator
- `base64`: encode string as base64
- `map`: transform value according to mappings expressed as `"value -> newValue"` strings
- `indent`: writes string content indented by N spaces
- `helmValue`: write the string content as a template value in final file

26
content/compose/bridge/transformation.md
View File

@ -1,26 +0,0 @@
---
title: Compose Bridge default transformation
description: Learn about the Compose Bridge default transformation
keywords: compose, bridge, kubernetes
---
{{< include "compose-bridge-early-access.md" >}}
Compose Bridge produces Kubernetes manifests so you can deploy
your Compose application to Kubernetes that is enabled on Docker Desktop.
Based on an arbitrary `compose.yaml` project, Compose Bridge will produce:
- A [Namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) so all your resources are isolated and don't colide with another deployment
- A [ConfigMap](https://kubernetes.io/docs/concepts/configuration/configmap/) with an entry for each and every config resource in your Compose model
- [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) for application services
- [Services](https://kubernetes.io/docs/concepts/services-networking/service/) for ports exposed by your services, used for service-to-service communication
- [Services](https://kubernetes.io/docs/concepts/services-networking/service/) for ports published by your services, with type `LoadBalancer` so that Docker Desktop will also expose same port on host
- [Network policies](https://kubernetes.io/docs/concepts/services-networking/network-policies/) to replicate the networking topology expressed in Compose
- [PersistentVolumeClaims](https://kubernetes.io/docs/concepts/storage/persistent-volumes/) for your volumes, using `hostpath` storage class so that Docker Desktop manages volume creation
- [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/) with your secret encoded - this is designed for local use in a testing environment
And a Kustomize overlay dedicated to Docker Desktop with:
- Loadbalancer for services which need to expose ports on host
- A PersistentVolumeClaim to use the Docker Desktop storage provisioner `desktop-storage-provisioner`
- A Kustomize file to link the all those resources together

81
content/compose/bridge/usage.md Normal file
View File

@ -0,0 +1,81 @@
---
title: Use the default Compose Bridge transformation
description: Learn about and use the Compose Bridge default transformation
keywords: compose, bridge, kubernetes
---
{{< include "compose-bridge-early-access.md" >}}
Compose Bridge supplies an out-of-the box transformation for your Compose configuration file. Based on an arbitrary `compose.yaml` file, Compose Bridge produces:
- A [Namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) so all your resources are isolated and don't conflict with resources from other deployments.
- A [ConfigMap](https://kubernetes.io/docs/concepts/configuration/configmap/) with an entry for each and every [config](../compose-file/08-configs.md) resource in your Compose application.
- [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) for application services. This ensures that the specified number of instances of your application are maintained in the Kubernetes cluster.
- [Services](https://kubernetes.io/docs/concepts/services-networking/service/) for ports exposed by your services, used for service-to-service communication.
- [Services](https://kubernetes.io/docs/concepts/services-networking/service/) for ports published by your services, with type `LoadBalancer` so that Docker Desktop will also expose the same port on the host.
- [Network policies](https://kubernetes.io/docs/concepts/services-networking/network-policies/) to replicate the networking topology defined in your `compose.yaml` file.
- [PersistentVolumeClaims](https://kubernetes.io/docs/concepts/storage/persistent-volumes/) for your volumes, using `hostpath` storage class so that Docker Desktop manages volume creation.
- [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/) with your secret encoded. This is designed for local use in a testing environment.
It also supplies a Kustomize overlay dedicated to Docker Desktop with:
- `Loadbalancer` for services which need to expose ports on host.
- A `PersistentVolumeClaim` to use the Docker Desktop storage provisioner `desktop-storage-provisioner` to handle volume provisioning more effectively.
- A Kustomize file to link all the resources together.
## Use the default Compose Bridge transformation
To use the default transformation run the following command:
```console
$ compose-bridge convert
```
Compose looks for a `compose.yaml` file inside the current directory and then converts it.
The following output is displayed
```console
$ compose-bridge convert -f compose.yaml
Kubernetes resource api-deployment.yaml created
Kubernetes resource db-deployment.yaml created
Kubernetes resource web-deployment.yaml created
Kubernetes resource api-expose.yaml created
Kubernetes resource db-expose.yaml created
Kubernetes resource web-expose.yaml created
Kubernetes resource 0-avatars-namespace.yaml created
Kubernetes resource default-network-policy.yaml created
Kubernetes resource private-network-policy.yaml created
Kubernetes resource public-network-policy.yaml created
Kubernetes resource db-db_data-persistentVolumeClaim.yaml created
Kubernetes resource api-service.yaml created
Kubernetes resource web-service.yaml created
Kubernetes resource kustomization.yaml created
Kubernetes resource db-db_data-persistentVolumeClaim.yaml created
Kubernetes resource api-service.yaml created
Kubernetes resource web-service.yaml created
Kubernetes resource kustomization.yaml created
```
These files are then stored within your project in the `/out` folder.
The Kubernetes manifests can then be used to run the application on Kubernetes using
the standard deployment command `kubectl apply -k out/overlays/desktop/`.
> **Note**
>
> Make sure you have enabled Kubernetes in Docker Desktop before you deploy your Compose Bridge transformations.
If you want to convert a `compose.yaml` file that is located in another directory, you can run:
```console
$ compose-bridge convert -f <path-to-file>/compose.yaml
```
> **Tip**
>
> Run `compose-bridge convert --help` to see all available flags.
{ .tip }
## What's next?
- [Explore how you can customize Compose Bridge](customize.md)
- [Explore the advanced integration](advanced-integration.md)

4
content/includes/compose-bridge-early-access.md
View File

@ -1,5 +1,7 @@
> **Early Access**
>
> Compose Bridge command line is an [early access](/release-lifecycle#early-access-ea) product.
> Compose Bridge is an [Early Access](/release-lifecycle#early-access-ea) product.
>
> If you would like to be considered for Compose Bridge testing, you can
> [sign up for the Early Access program](https://www.docker.com/docker-desktop-preview-program/).
{ .restricted }

12
data/toc.yaml
View File

@ -2144,7 +2144,17 @@ Manuals:
- path: /compose/migrate/
title: Migrate to Compose V2
- path: /compose/faq/
title: Compose FAQ
title: FAQs
- sectiontitle: Compose Bridge (Early Access)
section:
- path: /compose/bridge/
title: Overview
- path: /compose/bridge/usage/
title: Usage
- path: /compose/bridge/customize/
title: Customize
- path: /compose/bridge/advanced-integration/
title: Advanced
- path: /compose/release-notes/
title: Release notes