anchor.diff:  settings ensures only one step runs at a time, effectively creating a deploy
   queue.
   
  -Now the pipeline is wired up. Time for the deploy step.
  -
  -## Setup the Deploy Step
  -
  -Create a Kubernetes deployment manifest that references the `DOCKER_IMAGE`
  -environment variable. `kubectl` does not interpolate environment variables out
  -of the box, so you'll need a different solution. The `envsubst` command works
  -well for this case. `envsubst` ("environment substitute") replaces environment
  -variables from standard input. The result may be piped directly to `kubectl`.
  -
  -First, You'll need a deployment YML file. Call this file `k8s/deployment.yml`:
  +## Writing the Deploy Script
  +
  +The next step is writing a deploy script that generates a [Kubernetes deployment
  +manifest][k8s_deployment] from the `DOCKER_IMAGE` environment variable.
  +
  +Let's start with manifest file. This sample file creates a Deployment with
  +three replicas (horizontal scale in Kubernetes lingo) each listening port
  +`3000`. Change the `containerPort` to fit your application.
  +
  +<section class="Docs__note">
  +  <p>
  +    The <a
  +    href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/">official
  +    deployment documentation</a> covers much more than what fits in this
  +    tutorial. Refer back to these docs for information on setting CPU and
  +    memory, controlling networking, deployment update strategies, and how to
  +    expose your application to the internet.
  +  </p>
  +</section>
  +
  +Let's call this file `k8s/deployment.yml`.
   
   ```yml
   ---
  
positive.code: 
  ## Automate Deployments
  
  [Trigger steps](https://buildkite.com/docs/pipelines/trigger-step) connect
  pipelines. Add a trigger step to the existing test pipeline to trigger the
  deploy pipeline. You may also filter out branches with the `branches` option
  and set environment variables. Remember to set the `DOCKER_IMAGE` environment
  variable.
  
  Add these steps to your existing `.buildkite/pipeline.yml`:
  
  ```yml
    # Add a wait step to only deploy after all steps complete
    - wait
  
    - label: ':rocket: Deploy'
      trigger: kubernetes-tutorial-deploy
      branches: "master"
      build:
        message: "${BUILDKITE_MESSAGE}"
        commit: "${BUILDKITE_COMMIT}"
  
negative.code:       env:
          # TODO: replace with your Docker image name
          DOCKER_IMAGE: "asia.gcr.io/buildkite-kubernetes-tutorial/app:${BUILDKITE_BUILD_NUMBER}"
      branches: master
  ```
  
  It's magic time. Push some code. :tada: Continuous deployment!
  
  <%= image "final_test_pipeline.png" %>
  
  ## Next Steps
  
  Congratulations! :tada: You've setup a continuous deployment pipeline to
  Kubernetes. Practically speaking there are some things to do next. You could
  add a [block step](https://buildkite.com/docs/pipelines/block-step) before the
  trigger to enforce manual deploys on topic branches for example. You can also
  use [Github's Deployment API](https://buildkite.com/blog/github-deployments) to
  trigger deployments as well. You'll also want to expose your application to the
  internet with a [Kubernetes
  Service](https://kubernetes.io/docs/concepts/services-networking/service/).
  Lastly, generating manifests with `envsubst` only gets you so far. Projects
  like [kustomize](https://kustomize.io/) are better suited for this use case.
  
  ## Configuring kubectl Access
  
  Configuring `kubectl` access depends on your infrastructure. Here's an overview
  for common senarios.
  