Forem: Abhishek Anand Amralkar

My Zig with Ghostty

Abhishek Anand Amralkar — Thu, 09 Jan 2025 16:18:45 +0000

Ghostty is a fast, feature-rich, and cross-platform terminal emulator that uses platform-native UI and GPU acceleration. Ghostty is written in Zig.

Install:-

To install in MacOS

# update formulae
brew update

# stable
brew install --cask ghostty

# tip
brew install --cask ghostty@tip

Ghostty Docs

Actions:-

Ghostty supports below actions

Available actions:

  +version
  +help
  +list-fonts
  +list-keybinds
  +list-themes
  +list-colors
  +list-actions
  +show-config
  +validate-config
  +crash-report
  +show-face

see all available themes

ghostty +list-themes

see all keybindings

ghostty +list-keybinds

super + alt   + shift + j               write_scrollback_file:open
super + alt   + shift + w               close_all_windows
super + alt   + i                       inspector:toggle
super + alt   + right                   goto_split:right
super + alt   + down                    goto_split:bottom
super + alt   + left                    goto_split:left
super + alt   + up                      goto_split:top
super + ctrl  + equal                   equalize_splits
super + ctrl  + down                    resize_split:down,10
super + ctrl  + left                    resize_split:left,10
super + ctrl  + up                      resize_split:up,10
super + ctrl  + f                       toggle_fullscreen
super + ctrl  + right                   resize_split:right,10
super + shift + down                    jump_to_prompt:1
super + shift + w                       close_window
super + shift + left_bracket            previous_tab
super + shift + right_bracket           next_tab
super + shift + up                      jump_to_prompt:-1
super + shift + comma                   reload_config
super + shift + enter                   toggle_split_zoom
super + shift + j                       write_scrollback_file:paste
super + shift + d                       new_split:down
ctrl  + shift + left_bracket            previous_tab
ctrl  + shift + period                  move_tab:1
ctrl  + shift + comma                   move_tab:-1
ctrl  + shift + right_bracket           next_tab
ctrl  + shift + tab                     previous_tab
super + page_up                         scroll_page_up
super + physical:four                   goto_tab:4
super + backspace                       esc:
super + w                               close_surface
super + physical:eight                  goto_tab:8
super + down                            jump_to_prompt:1
super + enter                           toggle_fullscreen
super + t                               new_tab
super + c                               copy_to_clipboard
super + physical:one                    goto_tab:1
super + equal                           increase_font_size:1
super + physical:three                  goto_tab:3
super + right                           text:\x05
super + d                               new_split:right
super + plus                            increase_font_size:1
super + q                               quit
super + home                            scroll_to_top
super + left                            text:\x01
super + comma                           open_config
super + minus                           decrease_font_size:1
super + a                               select_all
super + n                               new_window
super + page_down                       scroll_page_down
super + left_bracket                    goto_split:previous
super + physical:nine                   last_tab
super + right_bracket                   goto_split:next
super + end                             scroll_to_bottom
super + zero                            reset_font_size
super + physical:five                   goto_tab:5
super + physical:seven                  goto_tab:7
super + up                              jump_to_prompt:-1
super + k                               clear_screen
super + s                               toggle_quick_terminal
super + physical:two                    goto_tab:2
super + physical:six                    goto_tab:6
super + v                               paste_from_clipboard
alt   + left                            esc:b
alt   + right                           esc:f
ctrl  + v                               new_split:right
ctrl  + h                               new_split:down
ctrl  + tab                             next_tab
ctrl  + z                               close_surface
shift + up                              adjust_selection:up
shift + left                            adjust_selection:left
shift + page_up                         adjust_selection:page_up
shift + end                             adjust_selection:end
shift + right                           adjust_selection:right
shift + page_down                       adjust_selection:page_down
shift + down                            adjust_selection:down
shift + home                            adjust_selection:home

For me migration from iTerm to Ghostty is super easy. I'm looking forward to using Ghostty as my default shell moving forward.

Oh, My Xmonad!

Abhishek Anand Amralkar — Sun, 23 Aug 2020 15:56:44 +0000

Well, I use Linux(On Debian Buster currently) on almost all of my personal laptops + desktop, and when you use Linux you get N numbers of options for almost everything to plug and play and use it.

In Linux, you have various GUIs available and my personal favorite is Gnome3 because of its clean user interface and the tweaks it allows for the look and feels.

The problems with GUIs

How to manage the various windows. I ended up buying an extra monitor.
Space issues like a title bar and subtitle bar etc so in the end you end up with a very small space (actually not that small) for your actual work.
Sometime it feels sluggish and needs a lot more resources than you want to spend on GUIs stuff.
The unwanted stuff you get along with the GUIs which you will never be going to use.

So What's the Fix?

Enter the Tiling Window Manager. There are many options available but my favorite is Xmonad.

Xmonad a minimal tiling window manager written in Haskell and DIY tiling manager which means it comes with no batteries you need to manage your Xmonad via a config file

~/.xmonad/xmonad.hs

Xmonad is very light and easy to use (actually not that easy) but man once you understand the terminologies you will love it and again you will learn little bit Haskell isn't it cool?

Another cool thing about the tiling window manager is you move towards a keyboard-driven approach and that means a less distraction at least for me and super productive.

Configurations

Let's walk through the config file snippet for the Xmonad

import XMonad
import System.Exit

import qualified XMonad.StackSet as W
import qualified Data.Map        as M

myTerminal      = "terminator"

myBorderWidth   = 1

myModMask       = mod1Mask

In the above config

I have defined my default terminal and I love Terminator .
I defined myModmask which means my modkey which I bind to mod1Mask which means the left Alt key on QWERTY keyboard.

Key Bindings

myKeys conf@(XConfig {XMonad.modMask = modm}) = M.fromList $

    [ ((modm .|. shiftMask, xK_Return), spawn $ XMonad.terminal conf)


    , ((modm , xK_Print), spawn "scrot screen_%Y-%m-%d-%H-%M-%S.png -d 1")


    , ((modm .|. controlMask, xK_Print), spawn "scrot window_%Y-%m-%d-%H-%M-%S.png -d 1-u")


    , ((modm,  xK_p), spawn "exe=`dmenu_path | dmenu` && eval \"exec $exe\"")


    , ((modm .|. shiftMask, xK_p), spawn "gmrun")


    , ((modm .|. shiftMask, xK_c), kill)


    , ((modm, xK_h), sendMessage Shrink)


    , ((modm,xK_l), sendMessage Expand)


    , ((modm,xK_t), withFocused $ windows . W.sink)
]

The above is just a snippet from my Xmonad config file. Let's go through the keywords we are seeing in the above snippet.

XMonad.modMask = modm

For my meta key or mod key, I will be using modm. Later part we can define our key bindings.

To launch a terminal

((modm .|. shiftMask, xK_Return), spawn $ XMonad.terminal conf)

The above code snippet will bind the meta key or mod key in my case its Alt key and shiftMask = Shift Key plus Enter = xK_Return to spawn my terminal which is Terminator.

ScreenShots

((modm , xK_Print), spawn "scrot screen_%Y-%m-%d-%H-%M-%S.png -d 1")

, ((modm .|. controlMask, xK_Print), spawn "scrot window_%Y-%m-%d-%H-%M-%S.png -d 1-u")

To take a screenshot for full screen or for the focused window bind the key modm and ControlKey + PrintScreen Key and it will spawn a daemon name scrot. On other note scrot stands for SCReenshoT.

Open a Menu or DMenu

((modm,  xK_p), spawn "exe=`dmenu_path | dmenu` && eval \"exec $exe\"")

The above command will open Dmenu and we can just type the program name we want to access like nautilus, brave, emacs etc.

To kill a focus window

((modm .|. shiftMask, xK_c), kill)

The above command which is alt and shift + c will kill the focused window.

To shrink the window

((modm, xK_h), sendMessage Shrink)

The above command which is alt + h will shrink the focused window.

To expand the window

((modm,xK_l), sendMessage Expand)

The above command which is alt + l will expand the focused window.

To move focus to next window

((modm,xK_j), sendMessage Expand)

To move focus to the previous window

((modm,xK_j), sendMessage Expand)

To switch between tiling mode

((modm, xK_space ), sendMessage NextLayout)

All above key bindings are a few drops out of the ocean. Please refer to the official documentation for more config settings.

Conclusion

Tiling window manager is really good when you need a minimal GUI and mostly your work is Keyboard driven.
Tiling window manager needs some learning actually it really needs to rewire your mind in order to operate.
Tiling window manager is lightweight and can work on low-end machines, old machines.

Happy Tiling!!

Collection Functions

Abhishek Anand Amralkar — Sat, 01 Aug 2020 16:58:35 +0000

concat

concat functions take 2 lists as a input and returns a new list

``

## element

`element` function in TF is selects single element from a list.

hcl
element(concat(aws_vpc.generic.*.id, [""]), 0)




In above code, we have used `concat` and `element` both with using `element` we are just selecting the value at the 0th index in the list.

## flatten

`flatten` function in

Collection Functions

Abhishek Anand Amralkar — Fri, 31 Jul 2020 09:26:36 +0000

The next in line is TF Collection Functions and they are very useful in day to day use for writing TF code.

concat

concat functions take 2 lists as an input and returns a new list.

concat(aws_vpc_endpoint.sts.*.id, [""])[0]

contains

contains functions checks for the element in the given list or set and returns a boolean.

contains(["a", "b", "c"], "a")
true

element

element functions return the item from the list given the index


element(var.azs, count.index)

The above code will return an availability zone at index start with count.index usually start from 0 and so on depending upon the count you set.

flatten

flatten takes a list and replaces any elements that are lists with a flattened sequence of the list contents.

flatten(module.nginx.vpc_security_group_ids)

With the above code, we can flatten the list of lists.

map takes an even number of arguments and returns a map whose elements are constructed from consecutive pairs of arguments.

map('BusinessUnit','XYZ')

merge

merge takes an arbitrary number of maps and returns a single map that contains a merged set of elements from all of the maps.

If more than one given map defines the same key then the one that is later in the argument sequence takes precedence.

tags = merge(
    {
      "Name" = format("%s-%03d-%s", var.namespace, count.index, var.environment)
    },
    var.tags,
  )

  volume_tags = merge(
    {
      "Name" = format("%s-%03d-%s", var.namespace, count.index, var.environment)
    },
    var.volume_tags,
  )

In the above code, we are merging all maps and passing them as a single map.

The above listed functions are few of the many Collection Functions Terraform have and are opiniaoted depending on my usage.

String Functions

Abhishek Anand Amralkar — Wed, 29 Jul 2020 17:59:37 +0000

format

format function produces a string by formatting a number of other values according to a specification string. Let's see an example

Note:- From now on we will refer Terraform as TF

We can use format function as a printf function in many other languages. I heavily used them in tagging my resources
in cloud.

  tags = merge(
    {
      "Name" = format("%s-%03d-%s", var.namespace, count.index, var.environment)
    },
    var.tags,
  )

or

name = format("%s-%s-%s", "elastic", var.environment, "SG")

consider variables are defined as below

variable "environment" {
  description = "Name of the Environment"
  type        = string
  default     = "Stage"
}


variable "namespace" {
  description = "Name to be used with identifier"
  type        = string
  default     = "elastic"
}

The above first code will generate the tag elastic-000-Stage and with count.index it will keep incrementing the %d depending upon the number defined and the second code block will generate elastic-Stage-SG.

join

join takes 2 input the separator and the list of string and concatenate them and returns the strings

For example, see below code block


role  = join("", aws_iam_role.elastic_iam_role.*.name)

The above code will generate the IAM role name as a string separated by blank space.

split

split function produces the list when given input as a string lets see example below


availability_zone = element(split(",", var.azs), count.index)

with the above code, we will get a list of all the availability zones (azs).

replace

replace function in TF is like sed in Linux it searches for the given string and replaces it.

is_t_instance_type = replace(var.instance_type, "/^t[23]{1}\\..*$/", "1") == "1" ? true : false

Your substring wrapped in // like /foo/ will be considered as a regular expression

In above example the value of var.instance_type will be replace by the regular expression which will match t2 and t3 instance families in aws.

Above functions are just very few out of mmany String Functions by Terraform.

Terraform Functions

Abhishek Anand Amralkar — Wed, 29 Jul 2020 17:59:33 +0000

I am using Terraform since I was a kid, just kidding. I first used Terraform when Terraform was at version 0.6 and since then I never looked back for any other cloud provisioning tool.

In this blog series, we will not discuss the basics of the terraform but rather we will try to see the Functions in Terraform, though we will not discuss all functions a few functions which are really helpful and widely used at least I have used them widely in my Terraform Code.

Below is the link for all the supported Functions in Terraform.

String
Collection
Filesystem
Date and Time
Type Conversion

Getting started with CDK for Terraform

Abhishek Anand Amralkar — Thu, 23 Jul 2020 16:13:16 +0000

CDK for Terraform

Hashicorp recently announced cdktf Cloud Development Kit for Terraform which currently supports Python3 and Typescript.

With cdktf we can write Terraform code in Python3 or Typescript instead of HCL which is the default language for Terraform.

Well, I thought of giving it a try and check out how it works out with Python3.

Install cdktf

To install the most recent stable release of cdktf, use npm.

npm install --global cdktf-cli

To get up to date with the cutting edge development version

npm install --global cdktf-cli@next

Once the installation is done you can check the cdktf installation via cdktf

Commands:
  cdktf deploy [OPTIONS]   Deploy the given stack
  cdktf destroy [OPTIONS]  Destroy the given stack
  cdktf diff [OPTIONS]     Perform a diff (terraform plan) for the given stack
  cdktf get [OPTIONS]      Generate CDK Constructs for Terraform providers and modules.
  cdktf init [OPTIONS]     Create a new cdktf project from a template.
  cdktf login              Retrieves an API token to connect to Terraform Cloud.
  cdktf synth [OPTIONS]    Synthesizes Terraform code for the given app in a directory.                                                                                                                                  [aliases: synthesize]

Options:
  --version          Show version number                                                                                                                                                                                             [boolean]
  --disable-logging  Dont write log files. Supported using the env CDKTF_DISABLE_LOGGING.                                                                                                                            [boolean] [default: true]
  --log-level        Which log level should be written. Only supported via setting the env CDKTF_LOG_LEVEL                                                                                                                            [string]
  -h, --help         Show help                                                                                                                                                                                                       [boolean]

Options can be specified via environment variables with the "CDKTF_" prefix (e.g. "CDKTF_OUTPUT")

Okay now, let's do some real work we will create a project where we will deploy Nginx on top of Docker using cdktf and Python3. For the Typescript example please check terraform-cdk.

Create a directory by any name in our case we will use below the python-docker

mkdir python-docker && cd $_

Initialize the project with the init command. We will use the --local flag so that the infrastructure state will be stored locally.

cdktf init --template=python --local

Make sure you pass python and not python3 else you will get below error

Invalid values:
  Argument: template, Given: "python3", Choices: "python", "typescript"

cdktf will generate the template for us, in our case, we will be using docker to get Nginx running so make sure to change the provider in cdktf.json

{
  "language": "python",
  "app": "pipenv run ./main.py",
  "terraformProviders": ["docker"],
  "codeMakerOutput": "imports"
}

Run the get command to download the dependencies for using Docker with Python.

cdktf get

Now add your code in main.py file for building Docker

First import the Docker provider, this means the imports is a local directory created by the above command

from imports.docker import Image, Container

and later add below code

docker_image = Image(self, 'nginx-latest', name='nginx:latest', keep_locally=False)

Container(self, 'nginx-cdktf', name='nginx-python-cdktf',
                  image=docker_image.name, ports=[
                      {
                          'internal': 80,
                          'external': 8000
                      }], privileged=False)

Add the dependencies in Pipenv file in our case

[packages]
constructs="3.0.4"
cdktf="0.0.12"

Pipenv will throw an error if you don't define the version for the packages

Run pipenv to get all the dependencies to install the pipenv check the official website pipenv

pipenv install

Now compile and generate Terraform configuration

cdktf synth

The above command will create a folder called cdktf.out that contains all Terraform JSON configuration that was generated.

We can run the regular Terraform commands

cd cdktf.out
terraform init
terraform plan
terraform apply

We can deploy

cdktf deploy

Lets see a demo

Manage Your Systems with Nix Package Manager

Abhishek Anand Amralkar — Mon, 13 Jul 2020 06:40:11 +0000

Nix Package Manager

We will walk through the Nix Package Manager and how we can build immutable systems. This is my first attempt to get Nix for all of my machines mostly Debian's(2 Laptops and 1 Desktop) and a MacBook.

The quickest way to install Nix is to open a terminal and run the following command (as a user other than root with sudo permission):

curl -L https://nixos.org/nix/install | sh

Add source $HOME/.nix-profile/etc/profile.d/nix.sh to your .bashrc or .zshrc.

echo 'source $HOME/.nix-profile/etc/profile.d/nix.sh' >> ~/.bashrc

The Basics

After installation we have some new commands available:

* nix-env used to install dependencies and alter your current profile
* nix-shell used to start shells based on nix expressions
* nix-store used to query or manipulate the nix store

Install a Package

nix-env -iA nixpkgs.clojure 

# Output
installing 'clojure-1.10.1.507'
building '/nix/store/y6r745pjimp232bgknncx27a074i4j0z-user-environment.drv'...
created 44 symlinks in user environment

Query a Package

nix-env -qaP 'consul'

# Output
nixpkgs.consul                      consul-1.7.2
nixpkgs.consul-alerts               consul-alerts-0.6.0
nixpkgs.consul-template             consul-template-0.19.4
nixpkgs.prometheus-consul-exporter  consul_exporter-0.3.0

Uninstall a Package

nix-env -e clojure

#Output
uninstalling 'clojure-1.10.1.507'

Nix Shell

Nix-shell lets you open a shell in a new environment.

In Nix; an environment is a collection of derivations (aka functions) that are put into your PATH.

We can create an environment by creating a .nix file to define the environment. Create a file called consul.nix with below content

Derivations

Nix is built around the concept of derivations. A derivation is simply defined as "a build action". It produces 1 (or maybe more) output paths in the nix store.

with import <nixpkgs> {};

let
  clj = pkgs.clojure;
in
stdenv.mkDerivation rec {
  name = "clojure-environment";

  buildInputs = [
    clj
    pkgs.leiningen
  ];

  shellHook = ''
    echo "using clojure: ${clojure.name}"
  '

and finally login to your env shell

nix-shell packages/clojure.nix
using clojure: clojure-1.10.1.507

To install packages from Non NixOS

{ pkgs ? import <nixpkgs> {} }:
with import <nixpkgs> {};

pkgs.stdenv.mkDerivation {
  name = "consul";

  src = pkgs.fetchurl {
    url = "https://releases.hashicorp.com/consul/1.8.0/consul_1.8.0_linux_amd64.zip";

    sha256 = "98df3e0a8ede84794fa4d20b1b6b5d52ad3b983dec916c4d612cecba7c48a421";
  };
  phases = ["unpackPhase" "installPhase"];



  unpackPhase = ''


'';

  installPhase = ''
    mkdir -p $out/bin
    ${pkgs.unzip}/bin/unzip $src -d $out/bin
    chmod +x $out/bin/consul

  '';
}

To run it

nix-env -f consul.nix -i

The stdenv

The standard build environment in the Nix Packages collection provides an environment for building Unix packages.

To build a package with the standard environment, you use the function stdenv.mkDerivation, instead of the primitive built-in function derivation, e.g.

with import <nixpkgs> {};

let
  py = pkgs.python;
in
stdenv.mkDerivation rec {
  name = "python-environment";

  buildInputs = [
    py
  ];

  shellHook = ''
    echo "using python: ${python.name}"
  '

The standard environment provides the following packages:

    The GNU C Compiler, configured with C and C++ support.
    GNU coreutils (contains a few dozen standard Unix commands).
    GNU findutils (contains find).
    GNU diffutils (contains diff, cmp).
    GNU sed.
    GNU grep.
    GNU awk.
    GNU tar.
    gzip and bzip2.
    GNU Make. 
    Bash. 
    The patch command.

Phases

    patch phase
    configure phase
    build phase
    check phase
    install phase
    buildup phase

Nix Expressions

Nix is not just a package manager. Nix is OS and a Language too.

The Nix expression language is a pure, lazy, functional language. Purity means that operations in the language don't have side-effects (for instance, there is no variable assignment). Laziness means that arguments to functions are evaluated only when they are needed. Functional means that functions are “normal” values that can be passed around and manipulated in interesting ways. The language is not a full-featured, general-purpose language. Its main job is to describe packages, compositions of packages, and the variability within packages.

In this blog, we just looked into just a small functionality of NIX. NIX is much more than that.

Happy Nixing!

Unspecified Location Constraint

Abhishek Anand Amralkar — Fri, 17 Apr 2020 05:14:37 +0000

I was creating an AWS S3 bucket using AWS CLI, but I was getting below error while creating bucket

Problem:

Command:-

aws s3api create-bucket --bucket abhishek-qa-state-store --region us-west-2

Error:-

An error occurred (IllegalLocationConstraintException) when calling the CreateBucket operation: The unspecified location constraint is incompatible for the region-specific endpoint this request was sent to.

Solution:

For any other region than us-east-1 in AWS, we need to define the LocationConstraint. Below is the command which will create a bucket for you in any other region apart from us-east-1

Command:-

aws s3api create-bucket --bucket abhishek-qa-state-store --region us-west-2 --create-bucket-configuration LocationConstraint=us-west-2

Output:-

{
    "Location": "http://abhishek-qa-state-store.s3.amazonaws.com/"
}

More info available here

AWS S3 Location Constraint

Hi, I'm Abhishek A Amralkar

Abhishek Anand Amralkar — Mon, 06 Mar 2017 04:55:41 +0000

I am DevOps Engineer and I have been coding for [2] years.

You can find me on Twitter as @aamralkar

I live in Pune.

I mostly program in these languages: [Clojure, Shell].

I am currently learning more about [Clojure, DevOPs].

Nice to meet you.