Paketo Buildpacks

https://paketo.io/docs/
Admin
Paketo Buildpacks is a framework for building container images from source code without requiring a...
Tokens:41,648
Snippets:610
Trust Score:8.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Clone and setup sample repository

Source: https://paketo.io/docs/howto/configuration

Initializes the working directory with the Paketo samples repository.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples
```

--------------------------------

### Append Arguments to Application Start Command

Source: https://paketo.io/docs/howto/java

Example of passing additional arguments to the application process, such as setting a custom server port.

```bash
docker run --rm --publish 8081:8081 samples/java --server.port=8081
curl -s http://localhost:8081/actuator/health
```

--------------------------------

### Run the application

Source: https://paketo.io/docs

Starts the built container image using Docker, mapping port 8080.

```bash
docker run -d -p 8080:8080 -e PORT=8080 paketo-demo-app
```

--------------------------------

### Create and build with a Procfile

Source: https://paketo.io/docs/howto/configuration

This example demonstrates creating a Procfile and building an image with a custom process type using the pack CLI.

```bash
echo "hello: echo hello world" > nodejs/yarn/Procfile
pack build samples/nodejs \
  --path nodejs/yarn \
  --buildpack paketo-buildpacks/nodejs \
  --buildpack paketo-buildpacks/procfile \
  --default-process hello
docker run samples/nodejs # should print "hello world"

```

--------------------------------

### Install a DEB file via Aptfile

Source: https://paketo.io/docs/howto/configuration

Include the direct URL to a DEB file on a single line within the Aptfile to install it.

```text
http://downloads.sourceforge.net/project/wkhtmltopdf/0.12.1/wkhtmltox-0.12.1_linux-precise-amd64.deb
```

--------------------------------

### View Buildpack Output

Source: https://paketo.io/docs/concepts/buildpacks

Example output from the pack build command showing the detection and building phases of Paketo buildpacks.

```text
...
===> DETECTING
paketo-buildpacks/node-engine 0.1.1
paketo-buildpacks/npm-install 0.2.0
paketo-buildpacks/npm-start   0.0.2
...
===> BUILDING
Paketo Node Engine Buildpack 0.1.1
...
Paketo NPM Install Buildpack 0.2.0
...
Paketo NPM Start Buildpack 0.0.2
...
```

--------------------------------

### Override Start Command with Interactive Shell

Source: https://paketo.io/docs/howto/java

Example of overriding the default entrypoint to launch an interactive Bash shell.

```bash
docker run --rm --entrypoint bash samples/java
```

--------------------------------

### Display SBOM directory structure

Source: https://paketo.io/docs/howto/sbom

Example output showing the directory structure of downloaded SBOM files.

```text
/tmp/demo-app-sbom
└── layers
    └── sbom
        └── launch
            ├── paketo-buildpacks_bellsoft-liberica
            │   ├── helper
            │   │   └── sbom.syft.json
            │   └── jre
            │       └── sbom.syft.json
            ├── paketo-buildpacks_ca-certificates
            │   └── helper
            │       └── sbom.syft.json
            ├── paketo-buildpacks_executable-jar
            │   ├── sbom.cdx.json
            │   └── sbom.syft.json
            ├── paketo-buildpacks_spring-boot
            │   ├── helper
            │   │   └── sbom.syft.json
            │   └── spring-cloud-bindings
            │       └── sbom.syft.json
            └── sbom.legacy.json

13 directories, 8 files
```

--------------------------------

### Run the Built Application

Source: https://paketo.io/docs/howto/create-paketo-buildpack

Command to start the containerized application using Docker.

```bash
docker run -d -p 8080:8080 -e PORT=8080 <app-name> "node server.js"
```

--------------------------------

### Buildpack Entry Example

Source: https://paketo.io/docs/concepts/sbom

Example of a buildpack entry for the Node.js runtime, containing detailed metadata and stack information.

```json
{
  "name": "Node Engine",
  "metadata": {
    "checksum": {
      "algorithm": "SHA-256",
      "hash": "a50ee095f936b51fffe5c032a7377a156723145c1ab0291ccc882f04719f1b54"
    },
    "cpe": "cpe:2.3:a:nodejs:node.js:16.7.0:*:*:*:*:*:*:*",
    "deprecation-date": "2024-04-30T00:00:00Z",
    "licenses": [
      "0BSD",
      "Apache-2.0",
      "Artistic-2.0",
      "BSD-2-Clause",
      "BSD-3-Clause",
      "BSD-3-Clause-Clear",
      "CC0-1.0",
      "MIT",
      "MIT-0",
      "Unicode-TOU"
    ],
    "purl": "pkg:generic/node@v16.7.0?checksum=0c4a82acc5ae67744d56f2c97db54b859f2b3ef8e78deacfb8aed0ed4c7cb690&download_url=https://nodejs.org/dist/v16.7.0/node-v16.7.0.tar.gz",
    "source": {
      "checksum": {
        "algorithm": "SHA-256",
        "hash": "0c4a82acc5ae67744d56f2c97db54b859f2b3ef8e78deacfb8aed0ed4c7cb690"
      },
      "uri": "https://nodejs.org/dist/v16.7.0/node-v16.7.0.tar.gz"
    },
    "stacks": [
      "io.buildpacks.stacks.bionic"
    ],
    "uri": "https://deps.paketo.io/node/node_v16.7.0_linux_x64_bionic_a50ee095.tgz",
    "version": "16.7.0"
  },
  "buildpacks": {
    "id": "paketo-buildpacks/node-engine",
    "version": "1.2.3"
  }
}
```

--------------------------------

### Define application directory structure

Source: https://paketo.io/docs/howto/go

Example directory layout for a Go application containing sub-packages.

```text
app-directory
├── handlers
│   └── details.go
└── main.go
```

--------------------------------

### Import sub-packages in main.go

Source: https://paketo.io/docs/howto/go

Example import statement for a sub-package within the application directory.

```go
import (
	"github.com/app-developer/app-directory/handlers"
)
```

--------------------------------

### View build output log

Source: https://paketo.io/docs

Example output showing the detection and build phases of the Paketo build process for a Java application.

```text
===> DETECTING
7 of 18 buildpacks participating
paketo-buildpacks/ca-certificates   2.3.2
paketo-buildpacks/bellsoft-liberica 8.2.0
paketo-buildpacks/maven             5.3.2
paketo-buildpacks/executable-jar    5.1.2
paketo-buildpacks/apache-tomcat     5.6.1
paketo-buildpacks/dist-zip          4.1.2
paketo-buildpacks/spring-boot       4.4.2
===> ANALYZING
Previous image with name "paketo-demo-app" not found
===> RESTORING
===> BUILDING

Paketo CA Certificates Buildpack 2.3.2
  https://github.com/paketo-buildpacks/ca-certificates
  Launch Helper: Contributing to layer
    Creating /layers/paketo-buildpacks_ca-certificates/helper/exec.d/ca-certificates-helper

Paketo BellSoft Liberica Buildpack 8.2.0
  https://github.com/paketo-buildpacks/bellsoft-liberica
  Build Configuration:
    $BP_JVM_VERSION              11              the Java version
  Launch Configuration:
    $BPL_JVM_HEAD_ROOM           0               the headroom in memory calculation
    $BPL_JVM_LOADED_CLASS_COUNT  35% of classes  the number of loaded classes in memory calculation
    $BPL_JVM_THREAD_COUNT        250             the number of threads in memory calculation
    $JAVA_TOOL_OPTIONS                           the JVM launch flags
  BellSoft Liberica JDK 11.0.12: Contributing to layer
    Downloading from https://github.com/bell-sw/Liberica/releases/download/11.0.12+7/bellsoft-jdk11.0.12+7-linux-amd64.tar.gz
    Verifying checksum
    Expanding to /layers/paketo-buildpacks_bellsoft-liberica/jdk
    Adding 129 container CA certificates to JVM truststore
    Writing env.build/JAVA_HOME.override
    Writing env.build/JDK_HOME.override
  BellSoft Liberica JRE 11.0.12: Contributing to layer
    Downloading from https://github.com/bell-sw/Liberica/releases/download/11.0.12+7/bellsoft-jre11.0.12+7-linux-amd64.tar.gz
    Verifying checksum
    Expanding to /layers/paketo-buildpacks_bellsoft-liberica/jre
    Adding 129 container CA certificates to JVM truststore
    Writing env.launch/BPI_APPLICATION_PATH.default
    Writing env.launch/BPI_JVM_CACERTS.default
    Writing env.launch/BPI_JVM_CLASS_COUNT.default
    Writing env.launch/BPI_JVM_SECURITY_PROVIDERS.default
    Writing env.launch/JAVA_HOME.default
    Writing env.launch/MALLOC_ARENA_MAX.default
  Launch Helper: Contributing to layer
    Creating /layers/paketo-buildpacks_bellsoft-liberica/helper/exec.d/active-processor-count
    Creating /layers/paketo-buildpacks_bellsoft-liberica/helper/exec.d/java-opts
    Creating /layers/paketo-buildpacks_bellsoft-liberica/helper/exec.d/link-local-dns
    Creating /layers/paketo-buildpacks_bellsoft-liberica/helper/exec.d/memory-calculator
    Creating /layers/paketo-buildpacks_bellsoft-liberica/helper/exec.d/openssl-certificate-loader
    Creating /layers/paketo-buildpacks_bellsoft-liberica/helper/exec.d/security-providers-configurer
    Creating /layers/paketo-buildpacks_bellsoft-liberica/helper/exec.d/security-providers-classpath-9
  JVMKill Agent 1.16.0: Contributing to layer
    Downloading from https://github.com/cloudfoundry/jvmkill/releases/download/v1.16.0.RELEASE/jvmkill-1.16.0-RELEASE.so
    Verifying checksum
    Copying to /layers/paketo-buildpacks_bellsoft-liberica/jvmkill
    Writing env.launch/JAVA_TOOL_OPTIONS.append
    Writing env.launch/JAVA_TOOL_OPTIONS.delim
  Java Security Properties: Contributing to layer
    Writing env.launch/JAVA_SECURITY_PROPERTIES.default
    Writing env.launch/JAVA_TOOL_OPTIONS.append
    Writing env.launch/JAVA_TOOL_OPTIONS.delim
```

--------------------------------

### Clone the Ruby sample application

Source: https://paketo.io/docs/howto/ruby

Retrieve the official Paketo samples repository and navigate to the Ruby Puma example directory.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/ruby/puma
```

--------------------------------

### Define package.json scripts

Source: https://paketo.io/docs/howto/nodejs

Example scripts configuration in package.json for use with build-time execution.

```json
{
  "scripts": { 
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test",
    "lint": "eslint src/**/*.js src/**/*.jsx",
  }
}
```

--------------------------------

### Set global composer install configurations

Source: https://paketo.io/docs/howto/php

Define global installation options using the BP_COMPOSER_INSTALL_GLOBAL environment variable.

```bash
pack build my-app --buildpack paketo-buildpacks/php \
  --env BP_COMPOSER_INSTALL_GLOBAL="friendsofphp/php-cs-fixer squizlabs/php_codesniffer=*"
```

--------------------------------

### Set composer install options

Source: https://paketo.io/docs/howto/php

Define command line flags for composer install using the BP_COMPOSER_INSTALL_OPTIONS environment variable.

```bash
pack build my-app --buildpack paketo-buildpacks/php \
  --env BP_COMPOSER_INSTALL_OPTIONS="--no-dev --prefer-install=auto"
```

--------------------------------

### Build Application with Apt Buildpack

Source: https://paketo.io/docs/howto/configuration

Execute the pack build command to trigger the Apt buildpack and install the dependencies specified in the Aptfile.

```bash
> pack build apps/nginx --buildpack paketo-buildpacks/apt --buildpack paketo-buildpacks/nginx
500a46ce47c1: Already exists
...
f5c5ce644ef6: Download complete
===> ANALYZING
[analyzer] Image with name "apps/nginx" not found
===> DETECTING
[detector] target distro name/version labels not found, reading /etc/os-release file
[detector] paketo-buildpacks/apt   0.1.0
[detector] paketo-buildpacks/nginx 1.0.11
===> RESTORING
===> BUILDING
[builder] target distro name/version labels not found, reading /etc/os-release file
[builder] -----> Detected Aptfile changes, flushing cache
[builder] -----> Updating apt caches
[builder]        Get:1 http://ports.ubuntu.com/ubuntu-ports jammy InRelease [270 kB]
[builder]        Get:2 http://ports.ubuntu.com/ubuntu-ports jammy-updates InRelease [128 kB]
[builder]        Get:3 http://ports.ubuntu.com/ubuntu-ports jammy-security InRelease [129 kB]
[builder]        Get:4 http://ports.ubuntu.com/ubuntu-ports jammy/universe arm64 Packages [17.2 MB]
[builder]        Get:5 http://ports.ubuntu.com/ubuntu-ports jammy/multiverse arm64 Packages [224 kB]
[builder]        Get:6 http://ports.ubuntu.com/ubuntu-ports jammy/main arm64 Packages [1758 kB]
[builder]        Get:7 http://ports.ubuntu.com/ubuntu-ports jammy-updates/multiverse arm64 Packages [46.0 kB]
[builder]        Get:8 http://ports.ubuntu.com/ubuntu-ports jammy-updates/universe arm64 Packages [1633 kB]
[builder]        Get:9 http://ports.ubuntu.com/ubuntu-ports jammy-updates/main arm64 Packages [3724 kB]
[builder]        Get:10 http://ports.ubuntu.com/ubuntu-ports jammy-security/universe arm64 Packages [1330 kB]
[builder]        Get:11 http://ports.ubuntu.com/ubuntu-ports jammy-security/main arm64 Packages [3407 kB]
[builder]        Get:12 http://ports.ubuntu.com/ubuntu-ports jammy-security/multiverse arm64 Packages [40.2 kB]
[builder]        Fetched 29.9 MB in 2s (12.2 MB/s)
[builder]        Reading package lists...
[builder] -----> Fetching .debs for mysql-client
[builder]        Reading package lists...
[builder]        Building dependency tree...
[builder]        The following additional packages will be installed:
[builder]          libbsd0 libedit2 libmd0 mysql-client-8.0 mysql-client-core-8.0 mysql-common
[builder]        The following NEW packages will be installed:
[builder]          libbsd0 libedit2 libmd0 mysql-client mysql-client-8.0 mysql-client-core-8.0
[builder]          mysql-common
[builder]        0 upgraded, 7 newly installed, 0 to remove and 6 not upgraded.
[builder]        Need to get 3209 kB of archives.
[builder]        After this operation, 62.1 MB of additional disk space will be used.
[builder]        Get:1 http://ports.ubuntu.com/ubuntu-ports jammy/main arm64 libmd0 arm64 1.0.4-1build1 [23.8 kB]
[builder]        Get:2 http://ports.ubuntu.com/ubuntu-ports jammy/main arm64 libbsd0 arm64 0.11.5-1 [43.7 kB]
[builder]        Get:3 http://ports.ubuntu.com/ubuntu-ports jammy/main arm64 libedit2 arm64 3.1-20210910-1build1 [96.0 kB]
[builder]        Get:4 http://ports.ubuntu.com/ubuntu-ports jammy-updates/main arm64 mysql-client-core-8.0 arm64 8.0.44-0ubuntu0.22.04.2 [3006 kB]
[builder]        Get:5 http://ports.ubuntu.com/ubuntu-ports jammy/main arm64 mysql-common all 5.8+1.0.8 [7212 B]
[builder]        Get:6 http://ports.ubuntu.com/ubuntu-ports jammy-updates/main arm64 mysql-client-8.0 arm64 8.0.44-0ubuntu0.22.04.2 [22.6 kB]
[builder]        Get:7 http://ports.ubuntu.com/ubuntu-ports jammy-updates/main arm64 mysql-client all 8.0.44-0ubuntu0.22.04.2 [9354 B]
[builder]        Fetched 3209 kB in 0s (7823 kB/s)
[builder]        Download complete and in download only mode
[builder] -----> Installing apt packages with dpkg
[builder]        libbsd0_0.11.5-1_arm64.deb
[builder]        libedit2_3.1-20210910-1build1_arm64.deb
[builder]        libmd0_1.0.4-1build1_arm64.deb
[builder]        mysql-client-8.0_8.0.44-0ubuntu0.22.04.2_arm64.deb
[builder]        mysql-client-core-8.0_8.0.44-0ubuntu0.22.04.2_arm64.deb
```

--------------------------------

### Define Project Structure

Source: https://paketo.io/docs/howto/nodejs

Example directory structure for a monorepo containing multiple applications.

```text
.
├── go-app
│   ├── go.mod
│   └── main.go
└── node-app
    ├── file.js
    ├── index.js
    └── package.json
```

--------------------------------

### Implement the Build Function

Source: https://paketo.io/docs/howto/create-paketo-buildpack

Defines the build logic using the Packit library to manage layers and install dependencies.

```go
package node

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"

	"github.com/BurntSushi/toml"
	"github.com/paketo-buildpacks/packit"
)

func Build() packit.BuildFunc {
	return func(context packit.BuildContext) (packit.BuildResult, error) {
		file, err := os.Open(filepath.Join(context.CNBPath, "buildpack.toml"))
		if err != nil {
			return packit.BuildResult{}, err
		}

		var m struct {
			Metadata struct {
				Dependencies []struct {
					URI string `toml:"uri"`
				} `toml:"dependencies"`
			} `toml:"metadata"`
		}
		_, err = toml.DecodeReader(file, &m)
		if err != nil {
			return packit.BuildResult{}, err
		}

		uri := m.Metadata.Dependencies[0].URI
		fmt.Printf("URI -> %s\n", uri)

		nodeLayer, err := context.Layers.Get("node")
		if err != nil {
			return packit.BuildResult{}, err
		}

		nodeLayer, err = nodeLayer.Reset()
		if err != nil {
			return packit.BuildResult{}, err
		}

		nodeLayer.Launch = true

		downloadDir, err := os.MkdirTemp("", "downloadDir")
		if err != nil {
			return packit.BuildResult{}, err
		}
		defer os.RemoveAll(downloadDir)

		fmt.Println("Downloading dependency...")
		err = exec.Command("curl",
			uri,
			"-o", filepath.Join(downloadDir, "node.tar.xz"),
		).Run()
		if err != nil {
			return packit.BuildResult{}, err
		}

		fmt.Println("Untaring dependency...")
		err = exec.Command("tar",
			"-xf",
			filepath.Join(downloadDir, "node.tar.xz"),
			"--strip-components=1",
			"-C", nodeLayer.Path,
		).Run()
		if err != nil {
			return packit.BuildResult{}, err
		}

		return packit.BuildResult{
			Plan: context.Plan,
			Layers: []packit.Layer{
				nodeLayer,
			},
		}, nil
	}
}
```

--------------------------------

### Build Java App with Node and Yarn

Source: https://paketo.io/docs/howto/java

Enable Node and Yarn installation by setting the BP_JAVA_INSTALL_NODE environment variable during the pack build command.

```bash
 pack build samples/java
--path java/maven-yarn --env BP_JAVA_INSTALL_NODE=true
```

--------------------------------

### Launch command for Framework-Dependent Deployments

Source: https://paketo.io/docs/reference/dotnet-core-reference

Invokes the dotnet CLI to start the application, binding to the port specified by the PORT environment variable or defaulting to 8080.

```bash
dotnet myapp.dll --urls http://0.0.0.0:${PORT:-8080}
```

--------------------------------

### Define Procfile for watchexec

Source: https://paketo.io/docs/howto/python

Configure the application start command in a Procfile to use watchexec for monitoring changes in the workspace.

```text
web: watchexec --verbose --restart --watch /workspace 'server.py'
```

--------------------------------

### Run and Verify Java Application

Source: https://paketo.io/docs/howto/java

Starts the containerized Java application and verifies its health status via the actuator endpoint.

```bash
docker run --rm --tty --publish 8080:8080 samples/java
curl -s http://localhost:8080/actuator/health | jq .
```

--------------------------------

### Build a Sample .NET Core App

Source: https://paketo.io/docs/howto/dotnet-core

Use the pack CLI to clone the samples repository and build a sample ASP.NET application using the Paketo buildpack.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/dotnet-core/aspnet
pack build my-app --buildpack paketo-buildpacks/dotnet-core \
  --builder paketobuildpacks/builder-jammy-base
```

--------------------------------

### Language Module Entry Example

Source: https://paketo.io/docs/concepts/sbom

Example of a language module entry for a Node.js module, generated by a dependency manager.

```json
{
  "name": "httpdispatcher",
  "metadata": {
    "licenses": [
      "MIT"
    ],
    "purl": "pkg:npm/httpdispatcher@2.1.2",
    "version": "2.1.2"
  },
  "buildpack": {
    "id": "paketo-buildpacks/node-module-bom",
    "version": "1.2.3"
  }
}
```

--------------------------------

### Build a Sample HTTPD App

Source: https://paketo.io/docs/howto/web-servers

Use the pack CLI to build a sample HTTPD application locally.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/httpd
pack build my-app --buildpack paketo-buildpacks/httpd \
  --builder paketobuildpacks/builder-jammy-full
```

--------------------------------

### Set up a directory for the service binding

Source: https://paketo.io/docs/howto/go

Create the necessary directory structure and files to store git credentials for private module access.

```bash
mkdir /tmp/git-binding
echo "git-credentials" > /tmp/git-binding/type
touch /tmp/git-binding/credentials
```

--------------------------------

### Clone the Go sample application

Source: https://paketo.io/docs/howto/go

Download the Paketo samples repository and navigate to the Go module sample directory.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/go/mod
```

--------------------------------

### Build a Sample PHP App

Source: https://paketo.io/docs/howto/php

Use the pack CLI to build a sample PHP application using the Paketo Full builder.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/php/builtin-server
pack build my-app --buildpack paketo-buildpacks/php \
  --builder paketobuildpacks/builder-jammy-full
```

--------------------------------

### Build a Sample Python App

Source: https://paketo.io/docs/howto/python

Use the pack CLI to build a sample Python application using the Paketo buildpack.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/python/pip
pack build my-app --buildpack paketo-buildpacks/python \
  --builder paketobuildpacks/builder-jammy-base
```

--------------------------------

### Clone the sample repository

Source: https://paketo.io/docs

Downloads the Paketo samples repository and navigates to the ASP.NET application directory.

```bash
git clone https://github.com/paketo-buildpacks/samples \
&& cd samples/dotnet-core/aspnet
```

--------------------------------

### Clone Java Sample Application

Source: https://paketo.io/docs/howto/app-monitor

Prepare the environment by cloning the Paketo Java samples repository.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/java
```

--------------------------------

### Build a Sample App with pack CLI

Source: https://paketo.io/docs/howto/web-servers

Commands to clone the samples repository and build an NGINX application using the pack CLI.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/nginx
pack build my-app --buildpack paketo-buildpacks/nginx \
  --builder paketobuildpacks/builder-jammy-base
```

--------------------------------

### Build a sample Node.js application

Source: https://paketo.io/docs/howto/nodejs

Use the pack CLI to clone and build a sample Node.js application with the Paketo buildpack.

```bash
git clone https://github.com/paketo-buildpacks/samples
cd samples/nodejs/npm
pack build my-app --buildpack paketo-buildpacks/nodejs \
  --builder paketobuildpacks/builder-jammy-base
```

--------------------------------

### Build Application with CA Certificates

Source: https://paketo.io/docs/howto/configuration

Build a sample application using the CA Certificates and Go buildpacks.

```bash
pack build samples/ca-certificates \
    --path ca-certificates \
    --buildpack paketo-buildpacks/ca-certificates \
    --buildpack paketo-buildpacks/go
```

--------------------------------

### Example Paketo SBOM output

Source: https://paketo.io/docs/howto/sbom

Sample JSON output showing the structure of the deprecated Paketo-specific SBOM metadata.

```json
{
  "remote": null,
  "local": [
    {
      "name": "Node Engine",
      "metadata": {
        "checksum": {
          "algorithm": "SHA-256",
          "hash": "a50ee095f936b51fffe5c032a7377a156723145c1ab0291ccc882f04719f1b54"
        },
        "cpe": "cpe:2.3:a:nodejs:node.js:16.7.0:*:*:*:*:*:*:*",
        "deprecation-date": "2024-04-30T00:00:00Z",
        "licenses": [
          "0BSD",
          "Apache-2.0",
          "Artistic-2.0",
          "BSD-2-Clause",
          "BSD-3-Clause",
          "BSD-3-Clause-Clear",
          "CC0-1.0",
          "MIT",
          "MIT-0",
          "Unicode-TOU"
        ],
        "purl": "pkg:generic/node@v16.7.0?checksum=0c4a82acc5ae67744d56f2c97db54b859f2b3ef8e78deacfb8aed0ed4c7cb690&download_url=https://nodejs.org/dist/v16.7.0/node-v16.7.0.tar.gz",
        "source": {
          "checksum": {
            "algorithm": "SHA-256",
            "hash": "0c4a82acc5ae67744d56f2c97db54b859f2b3ef8e78deacfb8aed0ed4c7cb690"
          },
          "uri": "https://nodejs.org/dist/v16.7.0/node-v16.7.0.tar.gz"
        },
        "stacks": [
          "io.buildpacks.stacks.bionic"
        ],
        "uri": "https://deps.paketo.io/node/node_v16.7.0_linux_x64_bionic_a50ee095.tgz",
        "version": "16.7.0"
      },
      "buildpacks": {
        "id": "paketo-buildpacks/node-engine",
        "version": "1.2.3"
      }
    },
    {
      "name": "node_modules",
      "metadata": {
        "build": true
      },
      "buildpacks": {
        "id": "paketo-buildpacks/npm-install",
        "version": "0.4.0"
      }
    },
    {
      "name": "node_modules",
      "metadata": {
        "launch": true
      },
      "buildpacks": {
        "id": "paketo-buildpacks/npm-install",
        "version": "0.4.0"
      }
    },
    {
      "name": "httpdispatcher",
      "metadata": {
        "licenses": [
          "MIT"
        ],
        "purl": "pkg:npm/httpdispatcher@2.1.2",
        "version": "2.1.2"
      },
      "buildpacks": {
        "id": "paketo-buildpacks/node-module-bom",
        "version": "1.2.3"
      }
    },
    {
      "name": "mime-types",
      "metadata": {
        "licenses": [
          "MIT"
        ],
        "purl": "pkg:npm/mime-types@2.1.32",
        "version": "2.1.32"
      },
      "buildpacks": {
        "id": "paketo-buildpacks/node-module-bom",
        "version": "1.2.3"
      }
    },
     {
      "name": "mime-db",
      "metadata": {
        "licenses": [
          "MIT"
        ],
        "purl": "pkg:npm/mime-db@1.49.0",
        "version": "1.49.0"
      },
      "buildpacks": {
        "id": "paketo-buildpacks/node-module-bom",
        "version": "1.2.3"
      }
    },
    {
      "name": "leftpad",
      "metadata": {
        "licenses": [
          "BSD-3-Clause"
        ],
        "purl": "pkg:npm/leftpad@0.0.1",
        "version": "0.0.1"
      },
      "buildpacks": {
        "id": "paketo-buildpacks/node-module-bom",
        "version": "1.2.3"
      }
    }
  ]
}
```

--------------------------------

### Build the Go application with pack

Source: https://paketo.io/docs/howto/go

Use the pack CLI to build the application into an OCI image using the Paketo Go Buildpack and the Jammy Base builder.

```bash
pack build my-app --buildpack paketo-buildpacks/go \
  --builder paketobuildpacks/builder-jammy-base
```

--------------------------------

### Initialize Go Project

Source: https://paketo.io/docs/howto/create-paketo-buildpack

Command to initialize a new Go module for the buildpack project.

```bash
go mod init </path/to/project>
```

--------------------------------

### Define Apt Packages in Aptfile

Source: https://paketo.io/docs/howto/configuration

Create an Aptfile in the root of your workspace with one package name per line.

```text
mysql-client
```

--------------------------------

### Configure Maven Exec Plugin for Yarn

Source: https://paketo.io/docs/howto/java

Add this plugin configuration to your pom.xml to execute yarn install during the build process.

```xml
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>${exec-maven.version}</version>
  <executions>
      <execution>
      <id>exec-yarn-install</id>
      <phase>generate-sources</phase>
          <goals>
              <goal>exec</goal>
          </goals>
          <configuration>
              <executable>yarn</executable>
              <arguments>
                  <argument>install</argument>
              </arguments>
          </configuration>
      </execution>
  </executions>
</plugin>
```

--------------------------------

### Build the application image

Source: https://paketo.io/docs

Uses the pack CLI to build an app image named paketo-demo-app using the jammy-base builder.

```bash
pack build paketo-demo-app --builder paketobuildpacks/builder-jammy-base
```

--------------------------------

### Build Phase Main Entrypoint

Source: https://paketo.io/docs/howto/create-paketo-buildpack

Skeleton code for the build binary main entrypoint.

```go
package main

import (
	"<path/to/project or github.com/<some-org or some-user>/<some-repo>>/node"
	"github.com/paketo-buildpacks/packit"
)

func main() {
	packit.Build(node.Build())
}
```

--------------------------------

### Extend a Paketo builder with Dockerfile

Source: https://paketo.io/docs/howto/builders

Create a custom builder image by extending a base Paketo builder and installing additional packages.

```dockerfile
cat > builder.Dockerfile << EOF
# pick a Paketo builder that suits your needs
FROM paketobuildpacks/builder-jammy-base:latest

# use the root user to enable privileged actions
USER 0:0

# install packages
RUN apt-get update && apt-get install \
  -y --no-install-recommends \
  git && \
  apt-get clean && \
  rm -rf /var/lib/apt/lists/*

# switch back to the cnb user to prevent
# consumers from executing privileged actions
USER cnb
EOF

docker build -t my-builder-image -f builder.Dockerfile .
```

--------------------------------

### Clone the Paketo Node.js sample repository

Source: https://paketo.io/docs

Downloads the sample application source code and navigates to the npm directory.

```bash
git clone https://github.com/paketo-buildpacks/samples \
&& cd samples/nodejs/npm
```

--------------------------------

### Run NGINX container with custom environment variables

Source: https://paketo.io/docs/howto/web-servers

Set specific environment variables when starting the container to control NGINX behavior.

```bash
docker run --tty --env PORT=8080 --env GZIP_DOWNLOADS=off --publish 8080:8080 my-nginx-image
```

--------------------------------

### Specify project path in project.toml

Source: https://paketo.io/docs/howto/dotnet-core

Define the startup project path within the project.toml configuration file.

```toml
[ _ ]
schema-version = "0.2"

[[ io.buildpacks.build.env ]]
  name = 'BP_DOTNET_PROJECT_PATH'
  value = './App'
```

--------------------------------

### Configure live reload in Tiltfile

Source: https://paketo.io/docs/howto/dotnet-core

Integrate Paketo buildpacks with Tilt to enable live updates and local resource rebuilding.

```python
pack(
  'myapp',
  env_vars=[
    'BP_DOTNET_PROJECT_PATH="./src"',
    'BP_LIVE_RELOAD_ENABLED=true'
    ],
  live_update=[
    sync('./build', '/workspace/build'),
    sync('./src', '/workspace/src'),
    run('cp -rf /workspace/build/* /workspace/', trigger='./build')
  ]
)
# (Re)build locally when source code changes

local_resource(
  'dotnet-publish',
  cmd='rm -rf ./build && dotnet publish src --configuration Release --runtime ubuntu.18.04-x64 --self-contained false --output ./build',
  deps=['src'],
  ignore=[
    'src/obj',
    'src/bin'
  ]
)
```

--------------------------------

### Build multiple Go packages via project.toml

Source: https://paketo.io/docs/howto/go

Configure multiple build targets in the project.toml file using a colon-delimited string.

```toml
# project.toml
[ _ ]
schema-version = "0.2"

[[ io.buildpacks.build.env ]]
  name="BP_GO_TARGETS"
  value="./first:./second"
```

--------------------------------

### Add custom repository and key to Aptfile

Source: https://paketo.io/docs/howto/configuration

Use the :repo:key and :repo:deb prefixes to register external repositories and their corresponding GPG keys.

```text
:repo:key https://dl.yarnpkg.com/debian/pubkey.gpg
:repo:deb https://dl.yarnpkg.com/debian/ stable main

yarn
```

--------------------------------

### Configure live reloading with Tilt

Source: https://paketo.io/docs/howto/go

Integrate the Paketo Go buildpack with Tilt for hot reloading, requiring local resource management for binary recompilation.

```python
pack('my-app',
  buildpacks=["paketo-buildpacks/go"],
  path='./src',
  env_vars=["BP_LIVE_RELOAD_ENABLED=true"],
  deps=['./src/build'],
  live_update=[
    sync('./src/build', '/tmp/tilt')  ,      
    run('cp -rf /tmp/tilt/* /layers/paketo-buildpacks_go-build/targets/bin', trigger=['./src/build']),
  ])

# (Re)build locally when source code changes
local_resource('go-build',
  cmd='GOOS=linux GOARCH=amd64 go build -o ./build/ -buildmode pie .',
  deps=['./src'],
  ignore=['./src/build'],
  dir='./src'
)
```

--------------------------------

### Clone the Paketo Python sample repository

Source: https://paketo.io/docs

Downloads the sample application source code and navigates into the pipenv directory.

```bash
git clone https://github.com/paketo-buildpacks/samples \
&& cd samples/python/pipenv
```

--------------------------------

### Build and Run Build Phase

Source: https://paketo.io/docs/howto/create-paketo-buildpack

Commands to compile the build binary and execute the pack build process.

```bash
GOOS=linux go build -ldflags="-s -w" -o ./bin/build ./cmd/build/main.go
pack build <app-name> \
  --path <path/to/app> \
  --buildpack <path/to/project> \
  --builder paketobuildpacks/builder-jammy-base \
  --verbose
```

--------------------------------

### Configure Dependency Mirrors via Bindings

Source: https://paketo.io/docs/howto/configuration

Use platform bindings to define mirrors where keys match the original URI hostname directly.

```text
/platform
    └── bindings
        └── dependency-mirror
            ├── default                     https://mirror.example.org/{originalHost}
            ├── github.com                  https://mirror.example.org/public-github
            ├── download.bell-sw.com        https://mirror.example.org/bell-sw
            └── type                        dependency-mirror
```

--------------------------------

### Configure an Alternative Native Image Toolkit

Source: https://paketo.io/docs/howto/java

Switches the default toolkit to GraalVM Community Edition by specifying buildpacks in the correct order.

```bash
pack build samples/native-image --buildpack paketo-buildpacks/graalvm --buildpack paketo-buildpacks/java-native-image`
```

--------------------------------

### Build a frontend app with HTTPD

Source: https://paketo.io/docs/howto/web-servers

Configures the build process to use Apache HTTP Server as the web server for the static assets.

```bash
pack build frontend-app --buildpack paketo-buildpacks/web-servers \
                          --env BP_NODE_RUN_SCRIPTS=build \
                          --env BP_WEB_SERVER=httpd \
                          --env BP_WEB_SERVER_ROOT=build
```

--------------------------------

### Build the Ruby application image

Source: https://paketo.io/docs/howto/ruby

Use the pack CLI to build the application into an OCI image using the Paketo Ruby buildpack and the Jammy base builder.

```bash
pack build my-app --buildpack paketo-buildpacks/ruby \
  --builder paketobuildpacks/builder-jammy-base
```

--------------------------------

### Build an app with pack CLI

Source: https://paketo.io/docs/howto/builders

Use the --builder flag to specify a Paketo builder image when building an application.

```bash
pack build my-nodejs-app --builder paketobuildpacks/builder-jammy-base:latest
```

--------------------------------

### Build a frontend app with NGINX

Source: https://paketo.io/docs/howto/web-servers

Configures the build process to use NGINX as the web server for the static assets.

```bash
pack build frontend-app --buildpack paketo-buildpacks/web-servers \
                          --env BP_NODE_RUN_SCRIPTS=build \
                          --env BP_WEB_SERVER=nginx \
                          --env BP_WEB_SERVER_ROOT=build
```

--------------------------------

### Enable Live Reloading via project.toml

Source: https://paketo.io/docs/howto/python

Configure the build environment by adding the BP_LIVE_RELOAD_ENABLED variable to the project.toml file.

```toml
[ _ ]
schema-version = "0.2"

[[ io.buildpacks.build.env ]]
  name = 'BP_LIVE_RELOAD_ENABLED'
  value = 'true'
```

--------------------------------

### Configure Tiltfile for Paketo Buildpacks

Source: https://paketo.io/docs/howto/java

Configure the Tiltfile to use the pack extension and define live update synchronization for Java classes.

```python
load('ext://pack', 'pack')

pack(
    'example-java-image',
    deps=['./bin/main'],
    live_update = [
        sync('./bin/main', '/workspace/BOOT-INF/classes'),
    ],
)
k8s_yaml('kubernetes.yaml')
k8s_resource('example-java', port_forwards=8000)
```

--------------------------------

### Provide a binding to pack build

Source: https://paketo.io/docs/howto/configuration

Mount a binding directory into the build container using the --volume flag.

```bash
pack build --volume <absolute-path-to-binding>:/platform/bindings/<binding-name> <image-name>

```

--------------------------------

### Configure workspace modules

Source: https://paketo.io/docs/howto/go

Use BP_GO_WORK_USE to initialize and include specific modules in a Go workspace before building.

```bash
pack build my-app --buildpack paketo-buildpacks/go \
  --env BP_GO_WORK_USE=./cmd/my-module \
  --env BP_GO_TARGETS=./cmd/my-module
```

--------------------------------

### Run the frontend app container

Source: https://paketo.io/docs/howto/web-servers

Executes the built container image to serve the application on the specified port.

```bash
docker run --tty --env PORT=8080 --publish 8080:8080 frontend-app
```

--------------------------------

### Select a web server with environment variables

Source: https://paketo.io/docs/howto/php

Use the BP_PHP_SERVER environment variable during the build process to specify the desired web server.

```bash
  pack build my-app --buildpack paketo-buildpacks/php \
  --env BP_PHP_SERVER="php-server"
```

--------------------------------

### Execute build with pack

Source: https://paketo.io/docs/howto/configuration

Run the pack build command to apply the configuration from the buildpack.yml file.

```bash
pack build samples/nodejs --path nodejs/yarn

```

--------------------------------

### Build a Native Image from Source with Maven

Source: https://paketo.io/docs/howto/java

Uses the pack CLI to build a native image directly from source code using Maven.

```bash
pack build samples/java-native \
  --env BP_NATIVE_IMAGE=true
  --path java/native-image/java-native-image-sample
```

--------------------------------

### Build Application with Pack

Source: https://paketo.io/docs/howto/create-paketo-buildpack

Command to build an application using the custom buildpack.

```bash
pack build <app-name> \
  --path <path/to/app> \
  --buildpack <path/to/project> \
  --builder paketobuildpacks/builder-jammy-base \
  --verbose
```

--------------------------------

### Switching to an alternative JVM buildpack

Source: https://paketo.io/docs/howto/java

Use two --buildpack arguments to specify an alternative JVM vendor and the standard Java buildpack, ensuring the alternative takes precedence.

```bash
pack build samples/jar --buildpack paketo-buildpacks/azul-zulu --buildpack paketo-buildpacks/java`
```

--------------------------------

### Enable Live Reloading in Tiltfile

Source: https://paketo.io/docs/howto/python

Configure the pack resource in a Tiltfile to enable live reloading and file synchronization.

```python
pack('my-app',
  buildpacks=["paketo-buildpacks/python"],
  env_vars=["BP_LIVE_RELOAD_ENABLED=true"],
  live_update=[
    sync('.', '/workspace'),
  ]
)
```

--------------------------------

### Configure Alternative Toolkit with Custom CA Certificates

Source: https://paketo.io/docs/howto/java

Ensures the CA certificates buildpack runs first to support custom certificate authorities when using an alternative toolkit.

```bash
pack build samples/jar --buildpack paketo-buildpacks/ca-certificates --buildpack paketo-buildpacks/graalvm --buildpack paketo-buildpacks/java-native-image`
```

--------------------------------

### Build process output

Source: https://paketo.io/docs/howto/create-paketo-buildpack

Expected output when running the build process.

```text
===> DETECTING
[detector] ======== Results ========
[detector] pass: com.example.node-engine@0.0.1
[detector] Resolving plan... (try #1)
[detector] com.example.node-engine 0.0.1
===> ANALYZING
[analyzer] Previous image with name "index.docker.io/library/test-node:latest" not found
===> RESTORING
===> BUILDING
[builder] URI -> https://nodejs.org/dist/v12.16.1/node-v12.16.1-linux-x64.tar.xz
[builder] ERROR: failed to build: exit status 1
[builder] always fail
ERROR: failed with status code: 7
```

--------------------------------

### Provide a binding to docker run

Source: https://paketo.io/docs/howto/configuration

Mount a runtime binding directory and set the SERVICE_BINDING_ROOT environment variable.

```bash
docker run --env SERVICE_BINDING_ROOT=/bindings --volume <absolute-path-to-binding>:/bindings/<binding-name> <image-name>

```

--------------------------------

### Build an app with private module access

Source: https://paketo.io/docs/howto/go

Use the pack CLI to provide the service binding and GOPRIVATE environment variable during the build process.

```bash
pack build myapp --buildpack paketo-buildpacks/go \
                 --env GOPRIVATE="github.com/private-org/private-module" \
                 --env SERVICE_BINDING_ROOT="/bindings" \
                 --volume /tmp/git-binding:/bindings/git-binding
```

--------------------------------

### Build a single non-default Go package via project.toml

Source: https://paketo.io/docs/howto/go

Define the build environment variable in a project.toml file to persist the build configuration.

```toml
# project.toml
[ _ ]
schema-version = "0.2"

[[ io.buildpacks.build.env ]]
  name="BP_GO_TARGETS"
  value="./second"
```

--------------------------------

### Configure Dependency Mirror via Binding

Source: https://paketo.io/docs/howto/configuration

Define a dependency mirror by creating a binding directory structure with a default file containing the mirror URI.

```text
/platform
    └── bindings
        └── dependency-mirror
            ├── default                https://mirror.example.org
            └── type                   dependency-mirror
```

--------------------------------

### Build and Run with Datadog Environment Variables

Source: https://paketo.io/docs/howto/app-monitor

Enable the Datadog Java Agent during build and configure it using environment variables at runtime.

```bash
pack build samples/java -e BP_DATADOG_ENABLED=true
```

```bash
docker run --rm --tty samples/java -e DD_SERVICE=foo-service -e DD_ENV=foo-env -e DD_VERSION=1.1.1
```

--------------------------------

### Configure the web directory

Source: https://paketo.io/docs/howto/php

Override the default web directory by setting the BP_PHP_WEB_DIR environment variable at build time.

```bash
  pack build my-app --buildpack paketo-buildpacks/php \
  --env BP_PHP_WEB_DIR="some-web-dir"
```

--------------------------------

### Build a reloadable Java image with pack

Source: https://paketo.io/docs/howto/java

Use the BP_LIVE_RELOAD_ENABLED environment variable to enable watchexec-based process reloading during the build.

```bash
pack build samples/java \
  --path java/jar \
  --env BP_LIVE_RELOAD_ENABLED=true
```

--------------------------------

### Configure YourKit Dependency Mirror

Source: https://paketo.io/docs/howto/java

Set this environment variable at build time to redirect YourKit downloads to their archive mirror.

```bash
BP_DEPENDENCY_MIRROR_DOWNLOAD_YOURKIT_COM=https://archive.yourkit.com
```

--------------------------------

### Specify project path with pack build flag

Source: https://paketo.io/docs/howto/dotnet-core

Use the --env flag to set the startup project path during the build process.

```bash
pack build my-app --env BP_DOTNET_PROJECT_PATH=./App
```

--------------------------------

### Copy Maven Settings

Source: https://paketo.io/docs/howto/java

Command to copy the local settings.xml file into the binding directory.

```bash
cp ~/.m2/settings.xml java/maven/binding/settings.xml
```
Tokens:
Raw