DEV Community: Tanmay Jain

asdf Basics & Cheat Sheet

Tanmay Jain — Thu, 01 Sep 2022 16:42:38 +0000

One tool to rule them all.

asdf is a tool version manager. Manage each of your project runtimes with a single CLI tool and command interface.

Features:

Large ecosystem of existing runtimes & tools. Simple API to add support for new tools as you need!
Support for existing config files .nvmrc, .node-versions, .ruby-version for smooth migration!
.tool-versions to manage all your tools, runtimes and their versions in a single, sharable place.
Supports Bash, ZSH, Fish & Elvish with completions available.
Provides a GitHub Action to install and utilize your .tool-versions in your CI/CD workflows.

Install ASDF

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.8.0

Add to ~/.bashrc

. $HOME/.asdf/asdf.sh

. $HOME/.asdf/completions/asdf.bash

Basic commands

Update asdf

asdf update

Add plugin (eg.: ruby)

asdf plugin add ruby

List all languages plugin:

asdf plugin list

asdf plugin list --urls

Update plugins

asdf plugin update --all

asdf plugin update ruby

Remove plugin

asdf plugin remove ruby

List all possible ruby versions

asdf list-all ruby

Install a ruby version using ruby plugin

asdf install ruby 3.0.0

List all installed ruby versions

asdf list ruby

Check current version of language plugin

asdf current ruby

Check current version of all languages plugin

asdf current

Check installation path of plugin version

asdf where

Change plugin version locally/globally

asdf local ruby 3.0.0

asdf global ruby 2.7.2

Remove asdf

Remove following from ~/.bashrc

. $HOME/.asdf/asdf.sh
. $HOME/.asdf/completions/asdf.bash

Run:

rm -rf ${ASDF_DATA_DIR:-$HOME/.asdf} ~/.tool-versions

Setup Docker locally for private registries

Tanmay Jain — Thu, 18 Aug 2022 09:42:34 +0000

Why would you need this setup ever?

For organizations that build their own Base Images or have custom Docker Base Images, will most likely be hosted on a private Docker Registry like AWS etc.

To run those Dockerfiles on your local machine, one would require to authenticate first. There can be external authorization services being used in combination with Docker Registries like Artifactory (jFrog).

What is a Docker (private) registry?

A Docker registry is a storage and distribution system for named Docker images.

A private Docker registry allows you to share and use base images within your organization. It is a centralized source of truth for the building blocks of your architecture.

Getting Started

In this example, we would focus on Artifactory as a Authorization Service for our private images and plugins.

Downloading the base Custom Image:

You will need to login into the Docker Registry using your credentials.

For Artifactory,

Login to your company's Artifactory client.
Click on top-right corner on your name.
Select Set me up
Package Type: docker
Select relevant Repository.

Now, you should see the command you need to run to authenticate and download private images.

It should be something like:

docker login {org-name}-{docker-repository-name}.jfrog.io

Alternatively, you can manually add your credentials in ~/.docker/config.json file like:

{
    "auths": {
        "https://{org-name}-{docker-repository-name}.jfrog.io": {
            "auth": "{username}:{PASSWORD} (converted to base 64)",
            "email": "youremail@email.com"
        }
    }
}

Now that you have access to download custom private images. Lets take a look at what our Dockerfile would look like and how can we install private libraries which are also hosted on Artifactory.

Setting up Dockerfile for private libraries:

We will be focusing on Artfactory as an authentication service for our private libraries / gems etc.

Our Dockerfile should look something like this:

# Fetch base image
FROM {org-name}-{docker-repository-name}.jfrog.io/{path-to-docker-image}
LABEL maintainer="Tanmay Jain <tanmayj28@gmail.com>"

# Setup your work directory
ARG APP_HOME=/home/app/web
WORKDIR $APP_HOME

# Copy required files
COPY Gemfile.lock $APP_HOME
RUN gem install bundler --force -N -v "$(tail -n 1 Gemfile.lock | tr -d '[:blank:]\n')" && bundle --version

COPY . $APP_HOME

RUN chown -R app:app $APP_HOME

USER app

# Setup ssh keys to allow installing gems from artifactory
ARG SSH_KEY
ENV SSH_KEY=$SSH_KEY

# Create id_rsa from string arg, and set permissions
RUN echo "$SSH_KEY" > /root/.ssh/id_rsa
RUN chmod 600 /root/.ssh/id_rsa

# Create known_hosts
RUN touch /root/.ssh/known_hosts

# bundle rubygems
ENV BUNDLE_DEPLOYMENT=true
ARG BUNDLE_JOBS=4
ARG BUNDLE_WITHOUT=development:test
RUN --mount=type=ssh,target=/home/app/.ssh/id_rsa,uid=9999,gid=9999 \
    --mount=type=secret,id=artifactory,uid=9999,gid=9999 \
    BUNDLE_{ORG-NAME}__JFROG__IO={JFROG_USERNAME}:{JFROG_API_KEY} bundle install

EXPOSE 3000
CMD ["bundle", "exec", "rails", "server"]

and we would build from our Dockerfile using command:

docker build --build-arg SSH_KEY="$(cat ~/.ssh/id_rsa)" .

Lets take a look at what we did above:

Following command would fetch your private custom base image which now you have access to.

FROM {org-name}-{docker-repository-name}.jfrog.io/{path-to-docker-image}

Following command would copy your Gemfile.lock, which is needed for bundlig gems. You would need other files like, package.json, yarn.lock Gemfile etc. ot be copied as well (as per need).

COPY Gemfile.lock $APP_HOME

Following command is used to add your private ssh keys which probably have access granted to download private libraries.

ARG SSH_KEY
ENV SSH_KEY=$SSH_KEY
RUN echo "$SSH_KEY" > /root/.ssh/id_rsa
RUN chmod 600 /root/.ssh/id_rsa
RUN touch /root/.ssh/known_hosts

Following command is used to install the private gems / libraries using the ssh key we just copied.

RUN --mount=type=ssh,target=/home/app/.ssh/id_rsa,uid=9999,gid=9999 \
    --mount=type=secret,id=artifactory,uid=9999,gid=9999 \
    BUNDLE_{ORG-NAME}__JFROG__IO={JFROG_USERNAME}:{JFROG_API_KEY} bundle install

And that is how you setup your local machine with Docker pulling images and libraries from your private stores.

Installing Gem in Production Rails console

Tanmay Jain — Sat, 11 Dec 2021 09:24:21 +0000

For a good few years, I have been using awesome_print for improved readability in rails console. But recently, I came across an issue where I had to read Audits from the console and my usual savior awesome_print wasn't bundled.

So, I stopped doing what I was meant to and spent next few hours figuring out, how can I install a gem in any environment without making code changes?

Apparently this is possible by updating the $LOAD_PATH variable and then requiring the gem manually.
In Ruby, an identifier starting with a $ symbol is a global variable. $LOAD_PATH is an array of absolute paths i.e it stores the exact location of all the dependencies in the project.

So, let's assume we want to install awesome_print in a production Rails Console. We can do so by following these steps:

SSH into the production server.
Run this to install the gem,

bundle install awesome_print

Run this to figure out the path where gem is installed,

gem which awesome_print

which should give something like,

/home/user/.asdf/installs/ruby/2.7.0/lib/ruby/gems/2.7.0/gems/awesome_print-1.9.2/lib/awesome_print.rb

Now, lets start our Rails console
We can add the path of this gem to the $LOAD_PATH global variable using:

$LOAD_PATH << /home/user/.asdf/installs/ruby/2.7.0/lib/ruby/gems/2.7.0/gems/awesome_print-1.9.2/lib

Let's try and require our freshly installed gem using:

require "/home/user/.asdf/installs/ruby/2.7.0/lib/ruby/gems/2.7.0/gems/awesome_print-1.9.2/lib/awesome_print.rb"

Follow the above steps and you should be able to install and use any gem you want on your production server without making any code changes.