---
title: New Relic NGINX integration buildpack for VMware Tanzu
source: https://docs.newrelic.com/docs/infrastructure/other-infrastructure-integrations/cloudfoundry-integrations/vmware-tanzu-nginx-buildpack-integration
---

Streamline NGINX monitoring and troubleshooting with the New Relic NGINX integration buildpack for VMware Tanzu. By automatically collecting and sending detailed inventory and performance metrics to the New Relic platform, you gain invaluable insights into connections, client requests, and overall server health. Correlate this data with VMware Tanzu infrastructure metrics from the [New Relic Firehose Nozzle](https://docs.newrelic.com/docs/infrastructure/host-integrations/host-integrations-list/cloudfoundry-integrations/vmware-tanzu-firehose-nozzle-integration/) for comprehensive environment visibility and rapid issue resolution.

## Requirements and compatibility [#requirements-compatibility]

We've certified the product with VMware Tanzu OpsManager versions up to v3.0.x, and Tanzu Application Service versions 4.x, 5.x, 6.x, and 10.x.

The New Relic NGINX integration buildpack for VMware Tanzu requires the following:

-   CF CLI: Version 6.38 or later is needed as this buildpack is installed as a multi-buildpack in the app manifest.
-   NGINX buildpack: This buildpack must be installed on top of the [`nginx_buildpack`](https://support.broadcom.com/group/ecx/productdownloads?subfamily=NGINX%20Buildpack).
-   New Relic account and license key: An active New Relic account with a license key is required. This key is used to bind NGINX servers to the New Relic infrastructure agent, which transmits metrics to the New Relic platform.

For general information about adding multiple buildpacks to manifests, see [Cloud Foundry documentation: Pushing an app with multiple buildpacks](https://docs.cloudfoundry.org/buildpacks/use-multiple-buildpacks.html).

### Version and support information [#version-and-support]

The following table provides version support information about the New Relic NGINX integration buildpack for VMware Tanzu.

| Element                                                      | Details                                                      |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| Tile version                                                 | 1.1.7                                                        |
| Release date                                                 | March 15, 2025                                               |
| Software component version                                   | New Relic NGINX integration buildpack for VMware Tanzu 1.1.7 |
| Compatible Ops Manager version(s)                            | 3.0.x                                                        |
| Compatible VMware Tanzu Application Service for VMs versions | 4.x, 5.x, 6.x, and 10.x                                      |
| BOSH stemcell version                                        | Ubuntu Jammy                                                 |
| CF Stack                                                     | cflinuxfs3, cflinuxfs4                                       |

## Installation and configuration [#install-and-configure]

This section describes how to install and configure the New Relic NGINX integration buildpack for VMware Tanzu.

You can install the buildpacks either as a tile in Ops Manager or individually using the CF CLI.

### Install via a tile in Ops Manager

1.  Download the latest version of the tile (currently `newrelic-nginx-buildpack-1.1.7.pivotal`) from the [Broadcom download site](https://support.broadcom.com/group/ecx/productdownloads?subfamily=New%20Relic%20Nginx%20Integration%20Buildpack%20for%20VMware%20Tanzu), or from New Relic's [GitHub repo under releases](https://github.com/newrelic/newrelic-pcf-nginx-buildpack/releases).
2.  Navigate to the Ops Manager Installation Dashboard and click **Import a Product** to upload the product file.
3.  Under the **Import a Product** button, click the **+** sign next to the version number of **New Relic NGINX Buildpack for Tanzu** to add the tile to your staging area.
4.  Click the newly added **New Relic NGINX Buildpack for Tanzu** tile.
5.  1.  Install and configure the tile in Ops Manager. You can accept the default values to install both buildpacks in your PCF foundation or select the checkbox for any buildpacks you wish to install under **Tile Configuration > New Relic Buildpack Selection**.

    2.  If you make any configuration changes, click the **Save** button on each tab at the bottom of the page.
6.  In Ops Manager, go to the installation UI and click **Apply changes**.

### Install via CF CLI

1.  Unzip `newrelic-nginx-buildpack-*.pivotal` into a separate subdirectory:
    ````sh
    unzip newrelic-pcf-nginx-buildpack-*.pivotal -d buildpack_tile
    ```

    ````
2.  Change directory to `buildpack_tile/releases`:
    ````sh
    cd buildpack_tile/releases
    ```

    ````
3.  Create a subdirectory, such as `tmp`:
    ````sh
    mkdir tmp
    ```

    ````
4.  Extract the `tgz` file in the releases folder into the `tmp`directory:
    ````sh
    tar xvf newrelic-pcf-nginx-buildpack-*.tgz -C tmp
    ```

    ````
5.  Change directory to `tmp/packages`:
    ````sh
    cd tmp/packages
    ```

    ````
6.  Extract any of the individual buildpack `.tgz` files using the following command:
    ````sh
    tar xvf newrelic_nginx_buildpack_cflinuxfs4.tgz
    ```

    OR

    ```sh
    tar xvf newrelic_nginx_buildpack_cflinuxfs3.tgz
    ```

    This will create a folder with the name of the buildpack, containing the zipped version of the buildpack.

    ````
7.  Upload the zipped buildpack file using the CF CLI's `cf create-buildpack` command:
    ````sh
    cf create-buildpack newrelic_nginx_buildpack-local newrelic_nginx_buildpack_cflinuxfs4/newrelic_nginx_buildpack-cached-cflinuxfs4-v*.zip 99
    ```

    OR

    ```sh
    cf create-buildpack newrelic_nginx_buildpack-local newrelic_nginx_buildpack_cflinuxfs3/newrelic_nginx_buildpack-cached-cflinuxfs3-v*.zip 99
    ```

    ````

## Buildpack build and deploy process [#buildpack-build-deploy]

The buildpacks in this tile are pre-built and ready for use in Cloud Foundry. However, if you want to make changes or update the cached version of any buildpacks with newer dependencies, you can build your own copy. Follow the instructions below to build and deploy your own copy.

### Build the buildpack [#build]

1.  Clone the buildpack repository to your system:
    ```sh
    git clone https://github.com/newrelic/newrelic-pcf-nginx-buildpack
    ```
2.  Change directory to the cloned buildpack.
3.  Source the `.envrc` file in the buildpack directory:
    ```sh
    source .envrc
    ```
4.  Install Bosh CLI and Tile Generator:
    ```sh
    ./scripts/setup.sh
    ```
5.  To build the buildpack, you have two options:

-   Only build the buildpack:

    ```sh
    make clean
    make package
    ```

    The following buildpacks will be generated:

    -   `build/newrelic_nginx_buildpack-cached-cflinuxfs4-v*.zip`
    -   `build/newrelic_nginx_buildpack-cached-cflinuxfs3-v*.zip`

        OR
-   Build the buildpack by creating a tile:

    ```sh
    make clean
    make all
    ```

    The following tile will be generated:

    -   `product/newrelic-pcf-nginx-buildpack-*.pivotal`

### Deploy to Cloud Foundry [#deploy]

1.  Upload the buildpack to Cloud Foundry and optionally specify it by name using the CF CLI:

    ```sh
    cf create-buildpack newrelic_nginx_buildpack [BUILDPACK_ZIP_FILE_PATH] 99
    ```

2.  Create a folder named `example` and download the `example.tar.gz` archive:

    ```sh
    mkdir example
    cd example
    wget https://github.com/newrelic/newrelic-pcf-nginx-buildpack/releases/download/v1.0.1/example.tar.gz
    ```

    **About the example directory**

    The `example` directory contains various artifacts necessary for the buildpack. Below is a description of each artifact and related documentation for reference:

    ````
    example/
    ├── buildpack.yml
    ├── manifest.yml
    ├── mime.types
    ├── nginx-config.yml
    ├── nginx.conf
    └── public
        └── index.html
    ```

    Artifacts descriptions:

    * [`buildpack.yml`](https://docs.cloudfoundry.org/buildpacks/nginx/index.html):
      * Contains configuration for the buildpack.
      * Action required: Update the NGINX version information to ensure compatibility with the latest version of the NGINX buildpack.

    * `manifest.yml`:
      * Defines the application-related configurations and metadata.
      * Action required: Update this file with the correct application information and ensure the buildpack order is correctly specified. This is crucial for the proper deployment of your application.
      * New Relic license key: This integration requires a [license key](/docs/apis/intro-apis/new-relic-api-keys/#license-key). You can set it in the `manifest.yml` file using the environment variable `NEW_RELIC_LICENSE_KEY: <ingest_key_value>`. Alternatively, the license key can be obtained from the New Relic service broker by binding the application.
      * Status port: Based on your NGINX configuration, the status port information is required. The default port value is `8080`, which can be set using the environment variable `STATUS_PORT: 8080`.
        * Note: Additional [environmental variables](/docs/infrastructure/install-infrastructure-agent/configuration/infrastructure-agent-configuration-settings/) can be set as per your requirements.
      * The `nginx_buildpack` must be installed before `newrelic_nginx_buildpack`.
        * Example: `cf push my_app -b nginx_buildpack -b newrelic_nginx_buildpack`
        * See the following pages for reference:
          * [Use multiple buildpacks](https://docs.cloudfoundry.org/buildpacks/use-multiple-buildpacks.html)
          * [nginx_buildpack documentation](https://docs.cloudfoundry.org/buildpacks/nginx/index.html)

    * [`mime.types`](https://docs.cloudfoundry.org/buildpacks/nginx/index.html):
      * Specifies MIME types required by the NGINX buildpack.
      * Note: Required by the NGINX buildpack for serving different file types with appropriate MIME types.

    * [`nginx.conf`](https://docs.cloudfoundry.org/buildpacks/nginx/index.html):
      * A primary template configuration file for NGINX.
      * Note: Required by the NGINX buildpack to configure how NGINX serves the application. Ensure that `location /nginx_status` in `nginx.conf` matches the `STATUS_URL` in `nginx-config.yml`.

    * [`nginx-config.yml`](/install/nginx/):
      * This template contains configuration settings for New Relic NGINX integration.
      * Action required: Refer to the [New Relic NGINX documentation](/install/nginx/) to understand various configuration options and adjust settings as necessary.
      * Note: Ensure that the `location /nginx_status` in `nginx.conf` matches the `STATUS_URL` in `nginx-config.yml`.

    * `public`:
      * Contains static files that NGINX will serve.
      * Note: The `index.html` file is crucial as the default file served by NGINX.

    Additional notes:

    * Ensure all configuration files are updated according to the latest documentation and version requirements.
    * Proper configuration is essential for the correct functionality of the buildpack and the application it serves.

    ````

3.  Push the application using the `cf push` command by using the `manifest.yml`:

    ```sh
        cf push
    ```

### (Optional) Bind your application to New Relic Broker Service [#bind-with-newrelic-broker-service]

To integrate your application with the [New Relic Broker Service](https://docs.newrelic.com/docs/infrastructure/host-integrations/host-integrations-list/cloudfoundry-integrations/vmware-tanzu-service-broker-integration/), follow these steps:

1.  Use the Cloud Foundry CLI to create a New Relic service instance:
    ```sh
    cf create-service newrelic <NEWRELIC_PLAN_NAME> <YOUR_NEWRELIC_SERVICE_INSTANCE_NAME>
    ```
    Make sure you replace `<NEWRELIC_PLAN_NAME>` with the desired New Relic plan and `<YOUR_NEWRELIC_SERVICE_INSTANCE_NAME>` with a name for your service instance.

2.  Bind your application to the New Relic service instance using the CF CLI:

    ```sh
    cf bind-service my_app <YOUR_NEWRELIC_SERVICE_INSTANCE_NAME>
    ```

    Make sure to replace `my_app` with the name of your application and `<YOUR_NEWRELIC_SERVICE_INSTANCE_NAME>` with the name of the New Relic service instance you created.

3.  Specify the New Relic service instance in the `services` section of your application's `manifest.yml` file:

    ```yaml
    services:
      - <YOUR_NEWRELIC_SERVICE_INSTANCE_NAME>
    ```

4.  Deploy your application with the updated manifest:

    ```sh
    cf push
    ```

## Monitoring with New Relic [#monitoring-with-New-Relic]

Once the application is successfully pushed, the NGINX integration will start sending NGINX metrics to New Relic.

To install the dashboard, [follow these UI instructions](https://one.newrelic.com/catalog-pack-details?state=952adb8f-8cd8-17ec-a55e-2a470ff27b54). Make sure you skip the installation and directly install the dashboard.

![screenshot of dashboard](https://docs.newrelic.com/images/integrations_screenshot-full_Nginx-Integration-Buildpack-for-VMware-Tanzu.webp "nginx dashboard")

You may also explore data further under **All entities > On Hosts > NGINX Servers**.

> #### ⚠️ IMPORTANT
>
> The cached version of this integration buildpack contains New Relic infrastructure agent `1.53.0` and New Relic NGINX integration `3.4.6`.

## Leave us feedback [#feedback]

If you have a feature request, questions, or information about a bug, please [submit a GitHub issue](https://github.com/newrelic/newrelic-pcf-nginx-buildpack/issues).
