instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from development
  builds. Here are a few examples of things you might want to add for production
  images.Multi-platformFor local development, you only need to build images for your local platform,
  since those images are just going to run on your machine. But for images that
  are pushed to a registry, it's often a good idea to build for multiple
  platforms, arm64 and amd64 in particular.AttestationsAttestations are manifests
  attached to the image that describe how the image was created and what
  components it contains. Attaching attestations to your images helps ensure that
  your images follow software supply chain best practices.AnnotationsAnnotations provide descriptive
  metadata for images. Use annotations to record arbitrary information and attach
  it to your image, which helps consumers and tools understand the origin,
  contents, and how to use the image.
  TipWhy not just define these additional build options in the Compose file
  directly?The build property in the Compose file format does not support all build
  features. Additionally, some features, like multi-platform builds, can
  drastically increase the time it takes to build a service. For local
  development, you're better off keeping your build step simple and fast,
  saving the bells and whistles for release builds.To add these properties to the images you build with Bake, update the Bake file
  as follows:
  
  group "default" {
   targets = ["vote", "result", "worker"]
  }
  
  target "_common" {
   annotations = ["org.opencontainers.image.authors=username"]
   platforms = ["linux/amd64", "linux/arm64"]
   attest = [
   "type=provenance,mode=max",
   "type=sbom"
   ]
  }
  
  target "vote" {
   inherits = ["_common"]
   target = "final"
  }
  
  target "result" {
   inherits = ["_common"]
  }
  
  target "worker" {
   inherits = ["_common"]
  }This defines a new _common target that defines reusable build configuration
  for adding multi-platform support, annotations, and attestations to your
  images. The reusable target is inherited by the build targets.With these changes, building the project with Bake produces three sets of
  multi-platform images for the linux/amd64 and linux/arm64 architectures.
  Each image is decorated with an author annotation, and both SBOM and provenance
  attestation records.ConclusionsThe pattern demonstrated in this guide provides a useful approach for managing
  production-ready Docker images in projects using Docker Compose. Using Bake
  gives you access to all the powerful features of Buildx and BuildKit, and also
  helps separate your development and build configuration in a reasonable way.Further readingFor more information about how to use Bake, check out these resources:Bake documentationBuilding with Bake
  ```