Modernize Your Builds with Cloud Native Build packs

When it comes to building and packaging containerized applications, most people tend to think of Docker. Docker is a powerful technology that has had a tremendous impact on the tech world. However, if you are still relying on manually creating a Dockerfile in your pipeline, it’s time to reconsider your approach.

When using the Dockerfile method, you typically create a Dockerfile manually, which then builds and packages the application into a container image. This image contains instructions to install the application code and container configurations. After creating the Dockerfile, you can use the Docker command line to build the container image, which can then be pushed into a container registry like ACR.

Now let’s consider using Cloud Native Buildpacks (CNB) instead. In a DevOps Pipeline, you can configure the CNB Build task to use an exclusive build pack for the application language and runtime. This task will automatically detect the application type and execute the appropriate build pack to build and package the application into a container image. Once the CNB task is configured, it will be executed to build the container image automatically, which can then be pushed into the container registry.

So why is CNB better than Docker packaging?

Firstly, the build process with CNB is much faster and streamlined. This is because, unlike Dockerfile, no manual intervention like writing a Dockerfile and manually configuring the container is required when relying on CNB. With CNB, the build and packaging process is completely automated.

Additionally, CNBs offer a consistent standard way of packaging applications. This means that your applications are packaged in a predictable and reproducible manner, regardless of the environment they are deployed in.

CNBs also offer security checks to ensure that container images are free from vulnerabilities. This can help you to mitigate security risks and ensure that your applications are safe to deploy.

Lastly, CNBs offer the flexibility to use existing build packs or to create your own custom build packs. This means that you can tailor your build process to your specific needs and optimize it for your specific application requirements.

Pipeline with CNB

# Build Pipeline with CNB
trigger:
- main

pool:
  vmImage: ubuntu-latest

steps:
- task: CloudNativeBuildpacks.buildpacks-build-task.Build@0
  inputs:
    platform: 'linux'
    namespace: 'myNamespace'
    imageRepository: 'myRepo'
    imageName: 'myImage'
    gitSourceUrl: 'https://github.com/arunprakashpj/myapp'

Pipeline without CNB

# Build Pipeline without CNB
trigger:
- main

pool:
  vmImage: ubuntu-latest

steps:
- task: Docker@2
  inputs:
    containerRegistry: 'myRegistry'
    repository: 'myRepo'
    command: 'build'
    Dockerfile: '**/Dockerfile'
    tags: |
      $(Build.BuildId)