4 posts tagged with "cli"

Overview​

Following up on the previous post about the best apps, let's look at recommended Command Line Interface (CLI) tools. All the tools introduced here have been used by me for at least 6 months and are essential installations when setting up new equipment.

zoxide​

GitHub - ajeetdsouza/zoxide: A smarter cd command. Supports all major shells.

A tool that eliminates the need to remember paths for directories you've visited before. For example:

cd ~/.config/somewhere/longlong/path

# Next time, you can visit directly with this command
z path

This is incredibly convenient as you no longer need to remember where specific configuration files are located. Using zi displays a priority list, allowing for fuzzy searching.

Once you try it, you'll never want to go back to the time before using this tool.

mise​

GitHub - jdx/mise: dev tools, env vars, task runner

A version manager for various environment variables, languages, and packages. It's highly stable due to its architecture and fast thanks to its Rust implementation. Its intuitive commands significantly reduce the learning curve.

I've already introduced it in a blog post, showing how much I love this tool. While there are several similar tools that can serve mise's role, I personally think it's the most recommendable among them. For example, direnv can be completely replaced by mise, and nix is overly complex with reduced versatility.

If you're a programming multilingual dealing with various languages, you should definitely try this.

chezmoi​

chezmoi

If you use multiple devices, synchronizing development environments can be quite troublesome, especially for developers who frequently use CLI.

If you're not planning to give up on synchronization entirely and are wondering how to synchronize, try chezmoi. Even if you purchase new equipment, you won't need to spend time on initial setup.

Like mise, there's a post about how to use it on this blog for reference.

fzf​

GitHub - junegunn/fzf: :cherry_blossom: A command-line fuzzy finder

With about 70k GitHub Stars, does it need more explanation? (For reference, spring-framework has 57k).

This open-source fuzzy finder, maintained by Korean developer junegunn, boasts incredible versatility through standard input/output piping.

If you need search functionality, regardless of the type, just use fzf. It's so widely used by various packages that you might have been using it indirectly without knowing of its existence.

fd​

GitHub - sharkdp/fd: A simple, fast and user-friendly alternative to 'find'

Replaces the find command.

Written in Rust and up to 50% faster than find. It has clean highlighting and much more intuitive command options compared to find.

ripgrep​

GitHub - BurntSushi/ripgrep: ripgrep recursively searches directories for a regex pattern while respecting your gitignore

Replaces the grep command. Although named ripgrep, it uses rg as the command.

Similar to fd, it's written in Rust. Compared to grep, you can get much more diverse information from the output. The commands are intuitive and easy to use, and with its speed, there's no reason not to use it.

Truly 'RIP, grep'.

lsd​

GitHub - lsd-rs/lsd: The next gen ls command

Replaces the ls command.

The ls command is incredibly frequently used. While the command itself is old, it doesn't provide diverse information in its output. Using lsd can completely replace the existing ls.

bat​

GitHub - sharkdp/bat: A cat(1) clone with wings.

Replaces the cat command.

While the cat command is simple output, using bat provides code highlighting. Sharp developers might worry about line output interfering with shell piping, but it doesn't interfere at all. Don't worry and enjoy this modern tool.

I use bat with an alias set to cat.

HTTPie​

HTTPie – API testing client that flows with you

Replaces curl.

Although there's also an APP version, making me wonder which article to include it in, I personally only use the CLI version, so I included it here.

The reason I prefer HTTPie over curl is that it's very, very intuitive. Simple GET requests can be sent like this:

https httpie.io/hello

The response comes formatted like this:

Think about curl responses. Developers like pretty things too.

Orbstack​

OrbStack · Fast, light, simple Docker & Linux

Replaces Docker Desktop.

When using Docker containers, it becomes a bit faster and eliminates some bugs. But its true value shows when using VMs - it can run VMs very lightly on Macs, where traditionally VMs were difficult to use. If you need to test on OSes like Ubuntu or Kali Linux, try using orbstack for very fast and convenient management. Personally, it was a very interesting experience.

atuin​

GitHub - atuinsh/atuin: ✨ Magical shell history

While chezmoi could synchronize tool settings, atuin can synchronize command history used at work. No more struggling to remember what commands you used at work.

atuin history list | fzf

trash-cli​

Implements "trash bin" functionality in the terminal. Therefore, you no longer need to fear rm -rf /. Because you can restore anything.

Do you need more reason than being free from rm -rf /, the developer's greatest enemy?

Conclusion​

So far, I've introduced several tools that I personally really like.

In fact, there are many more tools worth recommending, but whatever anyone recommends, what works best for you is what you're comfortable with. Find and try others that suit your environment.

Situation​

• As the codebase grows, the number of configuration values required for running a Spring application is increasing.
• While most situations are validated with test code, there are times when testing with bootRun locally is necessary.

Complication​

• Want to separate configuration values into environment variables for better management.
• .env files are typically ignored in Git, making version tracking difficult and prone to fragmentation.
  • Need a way to synchronize files across multiple machines.

Question​

• Is there a convenient method that minimizes friction among developers and is easy to apply?
  • Preferably a familiar method for easier maintenance.
• Can the version of .env files be managed?
• Is the learning curve low?
  • Want to avoid a situation where the solution is more complex than the problem.
• Can it be applied directly to the production environment?

Answer​

AWS S3​

• Updating .env files is convenient with AWS CLI.
• Version control of .env files can be done through snapshots.
• AWS S3 is a service familiar to most developers and has a low learning curve.
• In the AWS ECS production environment, system variables can be directly applied using S3 ARNs.

.

..

...

....

Is that all?​

If that's it, the article might seem a bit dull, right? Of course, there are still a few issues remaining.

Which Bucket is it in?​

When using S3, it's common to end up with many buckets due to file structure optimization or business-specific categorization.

aws s3 cp s3://something.service.com/enviroment/.env .env

If the .env file is missing, you'll need to download it using AWS CLI as shown above. Without someone sharing the bucket with you in advance, you might have to search through all buckets to find the environment variable file, which could be inconvenient. The intention was to avoid sharing, but having to receive something to share again might feel a bit cumbersome.

Too many buckets. Where's the env...?

Automating the process of exploring buckets in S3 to find and download the necessary .env file would make things much easier. This can be achieved by writing a script using tools like fzf or gum.

Spring Boot Requires System Environment Variables, Not .env...​

Some of you may have already noticed that Spring Boot reads system environment variables to fill in placeholders in YAML files. However, using just the .env file won't apply the system environment variables, thus not being picked up during Spring Boot's initialization process.

Let's briefly look at how it works.

# .env
HELLO=WORLD

# application.yml
something:
    hello: ${HELLO} # Retrieves the value from the HELLO environment variable on the OS.

@Slf4j
@Component
public class HelloWorld {

    @Value("${something.hello}")
    private String hello;

    @PostConstruct
    public void init() {
        log.info("Hello: {}", hello);
    }
}

SystemEnvironmentPropertySource.java

You can see that the placeholder in @Value is not resolved, causing the bean registration to fail and resulting in an error.

Just having a .env file doesn't register it as a system environment variable.

To apply the .env file, you can either run the export command or register the .env file in IntelliJ's run configurations. However, using the export command to register too many variables globally on your local machine can lead to unintended behavior like overwriting, so it's recommended to manage them individually through IntelliJ's GUI.

IntelliJ supports configuring .env files via GUI.

The placeholder is resolved and applied correctly.

Final Answer - The Real Final One​

Phew, the long process of problem identification and scoping has come to an end. Let's summarize the workflow once more and introduce a script.

1. Use an automation script to find and download the appropriate .env from S3.
2. Set the .env as system environment variables.

The shell script is written to be simple yet stylized using gum.

Full Code

#!/bin/bash

S3_BUCKET=$(aws s3 ls | awk '{print $3}' | gum filter --reverse --placeholder "Select...") # 1.

# Choose deployment environment
TARGET=$(gum choose --header "Select a environment" "Elastic Container Service" "EC2")
if [ "$TARGET" = "Elastic Container Service" ]; then
    TARGET="ecs"
else
    TARGET="ec2"
fi

S3_BUCKET_PATH=s3://$S3_BUCKET/$TARGET/

# Search for the env file
ENV_FILE=$(aws s3 ls "$S3_BUCKET_PATH" | grep env | awk '{print $4}' | gum filter --reverse --placeholder "Select...") # 2.

# Confirm
if (gum confirm "Are you sure you want to use $ENV_FILE?"); then
    echo "You selected $ENV_FILE"
else
    die "Aborted."
fi

ENV_FILE_NAME=$(gum input --prompt.foreground "#04B575" --prompt "Enter the name of the env file: " --value ".env" --placeholder ".env")
gum spin -s meter --title "Copying env file..." -- aws s3 cp "$S3_BUCKET_PATH$ENV_FILE" "$ENV_FILE_NAME" # 3.

echo "Done."

1. Use gum filter to select the desired S3 bucket.
2. Search for items containing the word env and assign it to a variable named ENV_FILE.
3. Finalize the object key of the .env file and proceed with the download.

I've created a demo video of the execution process.

Demo

After this, you just need to apply the .env file copied to the current directory to IntelliJ as mentioned earlier.

Conclusion​

• The script is easy to maintain due to its simplicity.
• Team response has been very positive.
• Developers appreciate aesthetics.
• For sensitive credentials, consider using AWS Secret Manager.

Overview​

While it is very convenient to be able to run kubectl through Google's Cloud Shell via the web from anywhere, there is a drawback of needing to go through the hassle of web access and authentication for simple query commands. This article shares a method for quickly managing Google Cloud Kubernetes using a local CLI.

Contents​

Installing GCP CLI​

First, you need to install the GCP CLI. Refer to the gcp-cli link to check for the appropriate operating system and install it.

Connection​

Once the installation is complete, proceed with the authentication process using the following command:

gcloud init

You need to access the GCP Kubernetes Engine and fetch the connection information for the cluster.

Copy the command for command-line access and execute it in the terminal.

gcloud container clusters get-credentials sv-dev-cluster --zone asia-northeast3-a --project {projectId}

Fetching cluster endpoint and auth data.
CRITICAL: ACTION REQUIRED: gke-gcloud-auth-plugin, which is needed for continued use of kubectl, was not found or is not executable. Install gke-gcloud-auth-plugin for use with kubectl by following https://cloud.google.com/blog/products/containers-kubernetes/kubectl-auth-changes-in-gke
kubeconfig entry generated for sv-dev-cluster.

Plugin Installation​

If the current Kubernetes version being used is below v1.26, you may encounter an error requesting the installation of gke-gcloud-auth-plugin. Install the plugin using the following command.

gcloud components install gke-gcloud-auth-plugin

Your current Google Cloud CLI version is: 408.0.1
Installing components from version: 408.0.1

┌────────────────────────────────────────────┐
│    These components will be installed.     │
├────────────────────────┬─────────┬─────────┤
│          Name          │ Version │   Size  │
├────────────────────────┼─────────┼─────────┤
│ gke-gcloud-auth-plugin │   0.4.0 │ 7.1 MiB │
└────────────────────────┴─────────┴─────────┘

For the latest full release notes, please visit:
  https://cloud.google.com/sdk/release_notes

Do you want to continue (Y/n)?  y

╔════════════════════════════════════════════════════════════╗
╠═ Creating update staging area                             ═╣
╠════════════════════════════════════════════════════════════╣
╠═ Installing: gke-gcloud-auth-plugin                       ═╣
╠════════════════════════════════════════════════════════════╣
╠═ Installing: gke-gcloud-auth-plugin                       ═╣
╠════════════════════════════════════════════════════════════╣
╠═ Creating backup and activating new installation          ═╣
╚════════════════════════════════════════════════════════════╝

Performing post processing steps...done.

Update done!

re-run the connection command, and you should see that the cluster is connected without any error messages.

gcloud container clusters get-credentials sv-dev-cluster --zone asia-northeast3-a --project {projectId}

Fetching cluster endpoint and auth data.
kubeconfig entry generated for sv-dev-cluster.

Once the connection is successful, you will also notice changes in Docker Desktop. Specifically, new information will be displayed in the Kubernetes tab.

Afterwards, you can also directly check GKE resources locally using kubectl.

kubectl get deployments
NAME                  READY   UP-TO-DATE   AVAILABLE   AGE
my-application        1/1     1            1           20d

Conclusion​

We have briefly explored efficient ways to manage GKE resources locally. Using kubectl locally enables extended features like autocomplete, making Kubernetes management much more convenient. If you are new to using GKE, I strongly recommend giving it a try.

Reference​

k8s-plugin

Overview​

CLI tool that can replace the curl command

If you are a developer who frequently uses Linux, you probably use the curl command often. It is an essential command for sending external API requests from a server, but it has the disadvantage of poor readability in the output. HTTPie is an interesting tool that can alleviate this drawback, so let's introduce it.

Install​

For Mac users, you can easily install it using brew.

brew install httpie

For CentOS, you can install it using yum.

yum install epel-release
yum install httpie

Usage​

First, here is how you would send a GET request using curl.

curl https://httpie.io/hello

Now, let's compare it with HTTPie.

https httpie.io/hello

The readability is much better in every aspect of the command. The response and header values are included by default, so you can get various information at a glance without using separate commands.

Note that https and http are distinguished in the command.

http localhost:8080

You can send a POST request as described on the official website.

http -a USERNAME POST https://api.github.com/repos/httpie/httpie/issues/83/comments body='HTTPie is awesome! :heart:'

Various other features are explained on GitHub, so if you make good use of them, you can greatly improve productivity.

Reference​

• httpie