TrackIt Blogs

TrackIt is an amazing product to manage and optimize your cloud billing. However, some customers aren’t ready and still wants to have a hands-on the solution they’re using for security or management reasons.

We are going to show you how you can use Replicated to transform TrackIt into an on-premise product.

In today’s world, we tend to externalize our resources. The cloud is certainly the future, but some businesses are not ready to jump in for reasons such as highly sensitive data, lack of trust or simply lack the budget.
How do you sell your cloud-oriented product to those companies who don’t want to externalize their data? How do you achieve on-premise distribution of your product? Replicated is the solution!

Replicated wraps your containerized cloud application with Enterprise-grade features and deploys it behind your customer’s firewall into a corporate data center or into the private cloud.

Prerequisites

• Sign up for a Replicated account (https://vendor.replicated.com/#/account/signup)
• A test machine (to simulate client environment) with tcp port 9870 to 9880 opened

Create a new Replicated project

Create a new application

Replicated allows you to manage every aspect of your product from image hosting to licensing  and distribution. For now, click on create new app to start the journey of our on premise TrackIT.
You can now see a brand new dashboard for your project.

You will be able to manage 3 distributions channels: stable, beta, unstable. Let’s create our first release by clicking on Create Release.

Upload our images

With Replicated, you can use images that are hosted on the Docker Hub, but it also enables the capability to host them on Replicated repository. This is the solution we are going to use.

For TrackIT we have to upload 3 of our images: the api, the webui and the loadbalancer (not mandatory). The rest of them are publicly available on the Docker Hub.

First let’s log on repgistry:

docker login registry.replicated.com

We need to tag each of our images

docker tag f7aebeee3cf8 registry.replicated.com/msolution/trackit-api:latest
docker tag 9208bd226c4d registry.replicated.com/msolution/trackit-webui:latest
docker tag 9534122d0bc1 registry.replicated.com/msolution/trackit-loadbalancer:latest

And now, let’s push them all:

docker push registry.replicated.com/msolution/trackit-api:latest
docker push registry.replicated.com/msolution/trackit-webui:latest
docker push registry.replicated.com/msolution/trackit-loadbalancer:latest

Configure your application

Replicated uses yaml syntax and has a logic similar to a docker-compose, this is the configuration we will use for TrackIT:

---
replicated_api_version: "1.3.2"
name: "msolution"
properties:
 app_url: ""
 logo_url: http://www.replicated.com/images/logo.png
 console_title: Your App Name
backup:
 enabled: false
monitors:
 cpuacct: []
 memory: []
components:
 - name: mysql
   containers:
     - source: public
       image_name: mysql
       version: latest
       env_vars:
         - name: MYSQL_ROOT_PASSWORD
           static_val: "very_secret_password"
       volumes:
         - host_path: /trackit/mysql
           container_path: /var/lib/mysql
       ports:
          - private_port: "3306"
            public_port: "3306"
            port_type: "tcp"
            interface: "docker0"
            when: ""
 - name: api
   containers:
     - source: replicated
       image_name: trackit-api
       version: latest
   ports:
     - private_port: "5000"
       public_port: "5000"
       port_type: "tcp"
       interface: "docker0"
   env_vars:
     - name: DEBUG
       static_val: "true"
   volumes:
     - host_path: /trackit/log
       container_path: /root/log
   extra_hosts:
     - hostname: mysql
       address: '{{repl ThisHostInterfaceAddress "docker0"}}'
     - hostname: redis
       address: '{{repl ThisHostInterfaceAddress "docker0"}}'
     - hostname: es1
       address: '{{repl ThisHostInterfaceAddress "docker0"}}'
 - name: webui
   containers:
     - source: replicated
       image_name: trackit-webui
       version: latest
    ports:
      - private_port: "8000"
        public_port: "8000"
        port_type: "tcp"
        interface: "docker0"
 - name: es1
   containers:
      - source: public
        image_name: elasticsearch
        version: 1.5.2
   volumes:
     - host_path: /trackit/data/es1
       container_path: /media/es-data1
     - host_path: /trackit/conf/elasticsearch
       container_path: /var/log/elasticsearch
   ports:
     - private_port: "9200"
       public_port: "9200"
       port_type: "tcp"
       interface: "docker0"
       when: ""
     - private_port: "9300"
       public_port: "9300"
       port_type: "tcp"
       interface: "docker0"
       when: ""
 - name: redis
   containers:
     - source: public
       image_name: redis
       version: latest
   ports:
     - private_port: "6379"
       public_port: "6379"
       interface: "docker0"
       when: ""
 - name: loadbalancer
   containers:
     - source: replicated
       image_name: trackit-loadbalancer
       version: latest
   ports:
     - private_port: "80"
       public_port: "80"
       port_type: "tcp"
       when: ""
     - private_port: "81"
        public_port: "81"
        port_type: "tcp"
        when: ""
     - private_port: "443"
       public_port: "443"
       port_type: "tcp"
       when: ""
   extra_hosts:
     - hostname: api
       address: '{{repl ThisHostInterfaceAddress "docker0"}}'
     - hostname: webui
       address: '{{repl ThisHostInterfaceAddress "docker0"}}'
config: []

This configuration describes all the containers we have. We can create links between them, set env vars, etc. Everything like a docker-compose file.

Release your first version

Save this configuration and go back on the Release page. We now need to release our first version. For that click on Promote

This dialog gives you the choice between 3 release channels. We will choose unstable for our example. Click on Promote Release.

Manage licenses and clients

Now your solution is ready to be shipped on premise. The next phase is to create and manage licenses for our clients. Each client will have its own license, and Replicated allows you to manage very precisely those licenses: duration, release channel, what action to take after expiration, etc.

Let’s create a license for our fictive customer of TrackIT:

Download the .rli license file and we are ready to install it on our client infrastructure.

Deploy your solution in your client’s on-premise infrastructure

Install Replicated client

Once everything is set up, deploying your solution is very easy. You just need to install the replicated client, load the license and you’re all set!

Install replicated client in one command:

curl -sSL https://get.replicated.com/docker | sudo bash
It will prompt you some straightforward questions about your infrastructure (private ip, proxy, etc). Once it’s done, go on https://yourip:8800/

SSL Certificate

At first launch, you will need to provide a SSL certificate or chose to use a self-signed certificate. In our case we will choose this last option by providing a hostname and clicking Using Self-Signed Cert

Upload client license

Here we will need to upload the license file we previously created for our client. This file is unique for each client.

Secure with password and preflight checks

Choose a password for admin console and make sure all your preflight checks are ok (and correct them if not)

Enjoy!

Now you’re on the client dashboard and Replicated has already launched the last version of the release channel you’ve previously designated for your client.
Your solution is now available on premise, and if you go on http://yourip:8080/ You will see your TrackIT on premise instance. Congratulations!

About TrackIt

TrackIt, an Amazon Web Services Advanced Consulting Partner based in Marina del Rey, CA, offers a range of cloud management, consulting, and software development solutions. Their expertise includes Modern Software Development, DevOps, Infrastructure-As-Code, Serverless, CI/CD, and Containerization, with a focus on Media & Entertainment workflows, High-Performance Computing environments, and data storage.

TrackIt excels in cutting-edge software design, particularly in the areas of containerization, serverless architectures, and pipeline development. The company’s team of experts can help you design and deploy a custom solution tailored to your specific needs.

In addition to cloud management and modern software development services, TrackIt also provides an open-source AWS cost management tool to help users optimize their costs and resources on the platform. With its innovative approach and expertise, TrackIt is the ideal partner for organizations seeking to maximize the potential of their cloud infrastructure.