Blueprint Walkthrough: Deploy a Docker Container

Docker

Blueprints are a key feature of XebiaLabs’ DevOps as Code approach; they guide teams through a fast, easy process that automatically generates YAML files that describe applications, infrastructure, and more as code that can be checked into a source control management system. Blueprints allow you to embed corporate policies, security requirements, and best practices in code that you can share across the enterprise, so it’s easier to on-board teams to the DevOps toolchain and migrate applications to new technologies such as container platforms and cloud-based environments.

XebiaLabs provides sample blueprints that help you migrate applications to platforms such as Amazon ECS and EKS—but you can build your own blueprints, too! For example, say you want to make it easy for Jane, a new developer, to deploy Docker containers on her local Docker installation. Let’s see what that would look like.

Step 1 Build the blueprint YAML file

The blueprint YAML file provides the questions that Jane will answer, defines default answers where needed, and identifies the templates (tmpl files) that the XL command-line interface (CLI) should use for the output. This example assumes that Jane’s application is packaged in two Docker images: one for the front end, and one for the back end.

apiVersion: xl/v1
kind: Blueprint
metadata:
  projectName: Docker Demo Application
  description: |
    The blueprint deploys a simple application in 2 Docker containers into your local Docker setup.
  author: XebiaLabs
  version: 1.0
parameters:
- name: AppName
  type: Input
  description: What is the Application name?
- name: ContainerPort
  type: Input
  description: At what port should the application be exposed in the container?
  default: 80
- name: HostPort
  type: Input
  description: At what port should the container port be mapped in the host?
  default: 8181
- name: BackendDockerImage
  type: Input
  description: What is the Docker Image (repo and path) for the Backend service?
  default: xebialabsunsupported/rest-o-rant-api
- name: FrontendDockerImage
  type: Input
  description: What is the Docker Image (repo and path) for the Frontend service?
  default: xebialabsunsupported/rest-o-rant-web
files:
- path: xebialabs/xld-environment.yaml.tmpl
- path: xebialabs/xld-docker-apps.yaml.tmpl
- path: xebialabs/xlr-pipeline.yaml.tmpl
- path: xebialabs.yaml

Step 2 Encode best practices in YAML templates

The magic of blueprints lies in templates for the YAML files that the XL CLI will generate. Templates enable you to build corporate requirements and technical best practices directly in code—no need for Jane to know the ins and outs of the target configuration.

In a template, the values between double curly brackets will be replaced with information that’s specific to Jane’s application and Docker setup. For example, this template requires an application name, the names of the two Docker images, and the port bindings to pass to the Docker installation.

{{$app := .AppName | kebabcase}}
apiVersion: xl-deploy/v1
kind: Applications
spec:
  - name: {{$app}}
    type: core.Directory
    children:
    - name: {{$app}}-backend
      type: udm.Application
      children:
        - name: '1.0'
          type: udm.DeploymentPackage
          deployables:
            - name: {{$app}}-network
              type: docker.NetworkSpec
              networkName: {{$app}}
              driver: bridge
            - name: {{$app}}-backend
              type: docker.ContainerSpec
              image: {{.BackendDockerImage}}
              networks:
                - {{$app}}
              showLogsAfter: 5
    - name: {{$app}}-frontend
      type: udm.Application
      children:
        - name: '1.0'
          type: udm.DeploymentPackage
          orchestrator:
            - sequential-by-dependency
          deployables:
            - name: {{$app}}-frontend
              type: docker.ContainerSpec
              image: {{.FrontendDockerImage}}
              networks:
                - {{$app}}
              showLogsAfter: 5
              portBindings:
                - name: ports
                  type: docker.PortSpec
                  hostPort: {{.HostPort}}
                  containerPort: {{.ContainerPort}}
                  protocol: tcp
              environment:
                API_ENDPOINT: http://{{$app}}-backend:8080/rest-o-rant-api

Step 3 Run the blueprint!

Jane just needs to install the XL CLI, execute xl blueprint, select the blueprint, and answer the questions that are defined in the blueprint YAML file.

The XL CLI uses Jane’s answers to generate YAML files based on the templates that you created. The xebialabs.yaml file points to the other generated files, so that Jane can later apply everything with a single CLI command.

In this case, Jane didn’t need to provide any sensitive data; but if that was required, the data would be stored in xlvals files. The gitignore file ensures that Jane doesn’t accidentally check sensitive data into source control management.

Step 4 Check out the YAML

Here’s the YAML file that is generated, based on the template above:

apiVersion: xl-deploy/v1
kind: Applications
spec:
  - name: rest-o-rant
    type: core.Directory
    children:
    - name: rest-o-rant-backend
      type: udm.Application
      children:
        - name: '1.0'
          type: udm.DeploymentPackage
          deployables:
            - name: rest-o-rant-network
              type: docker.NetworkSpec
              networkName: rest-o-rant
              driver: bridge
            - name: rest-o-rant-backend
              type: docker.ContainerSpec
              image: xebialabsunsupported/rest-o-rant-api
              networks:
                - rest-o-rant
              showLogsAfter: 5
    - name: rest-o-rant-frontend
      type: udm.Application
      children:
        - name: '1.0'
          type: udm.DeploymentPackage
          orchestrator:
            - sequential-by-dependency
          deployables:
            - name: rest-o-rant-frontend
              type: docker.ContainerSpec
              image: xebialabsunsupported/rest-o-rant-web
              networks:
                - rest-o-rant
              showLogsAfter: 5
              portBindings:
                - name: ports
                  type: docker.PortSpec
                  hostPort: 8181
                  containerPort: 80
                  protocol: tcp
              environment:
                API_ENDPOINT: http://rest-o-rant-backend:8080/rest-o-rant-api

Jane can check the generated YAML files into a source control management (SCM) system, in the same repository as her application code. SCM will secure the YAML files and make it easy for Jane’s team to collaborate on any modifications that are required in the future. SCM also tracks their changes and version-controls the files, so it’s easy to roll back unwanted changes.

Step 5 Bring it all together

After the YAML files are generated, Jane can put them to use! A simple xl apply command sends the YAML to the XebiaLabs DevOps Platform, which creates the required configuration items and release template.

Try it yourself

Are you using Docker? You can try this blueprint today! Just download the XL CLI and execute xl blueprint to access XebiaLabs’ publicly available blueprints. If you aren’t using the XebiaLabs DevOps Platform yet, sign up for a free trial to get started.

Check out a demo featuring Amazon EKS

Are you interested in a more advanced blueprint scenario? Check out this video, which shows how you can use DevOps as Code to deploy a microservice-based application on Amazon EKS.

Learn More

Related Posts

Leave a Comment

Your email address will not be published. Required fields are marked *