DEV Community: Tidal

Interactive CLI prompts in Go

Petr Razumov — Wed, 25 Aug 2021 18:24:42 +0000

Tidal Migrations 💓 CLI applications

Do you like CLI applications? We love them! At Tidal Migrations we use full-featured GUI IDEs and editors like VS Code and Emacs but also vim and git running in our terminals. Every day we use bash, awk, sed and lots of other CLI tools and apps for work and fun. Also, we like to develop CLI apps and with this post, we're going to show you how to implement different interactive prompts for your CLI apps written in Go.

Passing data to CLI apps

Oftentimes CLI applications don't just work by themselves, but some process or operation is required on the information or data.

There are different ways to pass data to command line applications. Using flags, environment variables, file names as CLI arguments or reading from standard input is quite common and is pretty easy to implement using just the standard Go library. Using interactive prompts can spice up your CLI application and improve the overall UX.

Let's get started!

How to implement text input prompt

The basic text input prompt is easy to implement. Just read from standard input until the new line character (\n):

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

// StringPrompt asks for a string value using the label
func StringPrompt(label string) string {
    var s string
    r := bufio.NewReader(os.Stdin)
    for {
        fmt.Fprint(os.Stderr, label+" ")
        s, _ = r.ReadString('\n')
        if s != "" {
            break
        }
    }
    return strings.TrimSpace(s)
}

func main() {
    name := StringPrompt("What is your name?")
    fmt.Printf("Hello, %s!\n", name)
}

How to implement password input prompt

Password prompts are similar to text input prompts, except the user's typed input should be hidden:

package main

import (
    "fmt"
    "os"
    "syscall"

    "golang.org/x/term"
)

// PasswordPrompt asks for a string value using the label.
// The entered value will not be displayed on the screen
// while typing.
func PasswordPrompt(label string) string {
    var s string
    for {
        fmt.Fprint(os.Stderr, label+" ")
        b, _ := term.ReadPassword(int(syscall.Stdin))
        s = string(b)
        if s != "" {
            break
        }
    }
    fmt.Println()
    return s
}

func main() {
    password := PasswordPrompt("What is your password?")
    fmt.Printf("Oh, I see! Your password is %q\n", password)
}

How to implement Yes/No prompt

For Yes/No prompts we're going to create an infinite loop to keep asking until the user answers yes or no:

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

// YesNoPrompt asks yes/no questions using the label.
func YesNoPrompt(label string, def bool) bool {
    choices := "Y/n"
    if !def {
        choices = "y/N"
    }

    r := bufio.NewReader(os.Stdin)
    var s string

    for {
        fmt.Fprintf(os.Stderr, "%s (%s) ", label, choices)
        s, _ = r.ReadString('\n')
        s = strings.TrimSpace(s)
        if s == "" {
            return def
        }
        s = strings.ToLower(s)
        if s == "y" || s == "yes" {
            return true
        }
        if s == "n" || s == "no" {
            return false
        }
    }
}

func main() {
    ok := YesNoPrompt("Dev.to is awesome!", true)
    if ok {
        fmt.Println("Agree!")
    } else {
        fmt.Println("Huh?")
    }
}

How to implement interactive checkboxes

To create an interactive multi-select prompt we're going to use an awesome survey package:

package main

import (
    "fmt"
    "strings"

    "github.com/AlecAivazis/survey/v2"
)

func Checkboxes(label string, opts []string) []string {
    res := []string{}
    prompt := &survey.MultiSelect{
        Message: label,
        Options: opts,
    }
    survey.AskOne(prompt, &res)

    return res
}

func main() {
    answers := Checkboxes(
        "Which are your favourite programming languages?",
        []string{
            "C",
            "Python",
            "Java",
            "C++",
            "C#",
            "Visual Basic",
            "JavaScript",
            "PHP",
            "Assembly Language",
            "SQL",
            "Groovy",
            "Classic Visual Basic",
            "Fortran",
            "R",
            "Ruby",
            "Swift",
            "MATLAB",
            "Go",
            "Prolog",
            "Perl",
        },
    )
    s := strings.Join(answers, ", ")
    fmt.Println("Oh, I see! You like", s)
}

Caveats and workarounds

If you pipe some input data to your interactive CLI app, the prompts will read that data:

$ echo "Petr" | go run main.go
What is your name? Hello, Petr!

Sometimes such behavior is acceptable, but sometimes not. To check if the terminal is interactive let's use term.IsTerminal function:

package main

import (
    "fmt"
    "syscall"

    "golang.org/x/term"
)

func main() {
    if term.IsTerminal(int(syscall.Stdin)) {
        fmt.Println("Terminal is interactive! You're good to use prompts!")
    } else {
        fmt.Println("Terminal is not interactive! Consider using flags or environment variables!")
    }
}

$ echo "Hello" | go run main.go
Terminal is not interactive! Consider using flags or environment variables!

$ go run main.go
Terminal is interactive! You're good to use prompts!

Libraries

As you can see, it's pretty easy to implement basic interactive prompts, but for complex ones it's better to use some Go packages from the community:

AlecAivazis / survey

A golang library for building interactive and accessible prompts with full support for windows and posix terminals.

Survey

A library for building interactive and accessible prompts on terminals supporting ANSI escape sequences.

⚠️ This project is no longer maintained. For an alternative, please check out: https://github.com/charmbracelet/bubbletea ⚠️

Hey everyone! I finally came to terms with the fact that I can no longer dedicate enough time to keep this library alive This project outgrew my wildest expectations and was such a great experience. If someone else wants to take over maintainence please reach out

package main
import (
    "fmt"
    "github.com/AlecAivazis/survey/v2"
)

// the questions to ask
var qs = []*survey.Question{
    {
        Name:     "name",
        Prompt:   &survey.Input{Message: "What is your name?"},
        Validate: survey.Required,
        Transform: survey.Title,
    },
    {
        Name: "color",
        Prompt: &survey.Select{
            Message: "Choose a color:",
            Options: []string{"red"

…

View on GitHub

Songmu / prompter

golang utility for easy prompting

prompter

Description

utility for easy prompting in Golang

Synopsis

twitterID := prompter.Prompt("Enter your twitter ID", "")
lang := prompter.Choose("Which language do you like the most?", []string{"Perl", "Golang", "Scala", "Ruby"}, "Perl")
passwd := prompter.Password("Enter your password")
var likeSushi bool = prompter.YN("Do you like sushi?", true)
var likeBeer bool = prompter.YesNo("Do you like beer?", false)

Features

Easy to use
Care non-interactive (not a tty) environment
- Default is used and the process is not blocked
No howeyc/gopass (which uses cgo) dependency
- cross build friendly
Customizable prompt setting by using &prompter.Prompter{} directly

License

MIT

Author

Songmu

View on GitHub

manifoldco / promptui

Interactive prompt for command-line applications

promptui

Interactive prompt for command-line applications.

We built Promptui because we wanted to make it easy and fun to explore cloud services with manifold cli.

Code of Conduct | Contribution Guidelines

Overview

Promptui is a library providing a simple interface to create command-line prompts for go. It can be easily integrated into spf13/cobra urfave/cli or any cli go application.

Promptui has two main input modes:

Prompt provides a single line for user input. Prompt supports optional live validation, confirmation and masking the input.
Select provides a list of options to choose from. Select supports pagination, search, detailed view and custom templates.

For a full list of options check GoDoc.

Basic Usage

Prompt

package main
import (
    "errors"
    "fmt"
    "strconv"

    "github.com/manifoldco/promptui"
)

func main() {
    validate := func(input string) error {
        _, err := strconv.ParseFloat(input, 64)
        if

…

View on GitHub

Conclusion

That's it! We hope you liked it! Code examples are available on GitHub.

If you're interested in CLI applications development in Go and we — Tidal Migrations — are hiring! Please check our Careers page!

Long live the command line!

Automating multi-arch container images builds (we used Google Cloud Build but GitHub Actions would also work)

Petr Razumov — Tue, 29 Jun 2021 11:52:30 +0000

This is the last post in the series on how we prepared our application to run on M1 (Apple Silicon).

In the previous part we were talking about building multiple CPU architecture container images.

This post will guide you through how to implement a pipeline for building multi-architecture container images using Google Cloud Platform’s Cloud Build or GitHub Actions.

As you may know from the previous post, to build multi-arch container images we need to setup virtual environment and run docker buildx.

Let's configure such build pipelines for some popular CI/CD solutions.

Cloud Build

Cloud Build is a service that executes your builds on Google Cloud Platform's infrastructure.

To run multi-arch container images builds let's use the following pipeline configuration:

steps:
  - name: gcr.io/cloud-builders/docker
    args:
      - run
      - '--privileged'
      - 'linuxkit/binfmt:v0.7'
    id: initialize-qemu
  - name: gcr.io/cloud-builders/docker
    args:
      - buildx
      - create
      - '--name'
      - mybuilder
    id: create-builder
  - name: gcr.io/cloud-builders/docker
    args:
      - buildx
      - use
      - mybuilder
    id: select-builder
  - name: gcr.io/cloud-builders/docker
    args:
      - buildx
      - inspect
      - '--bootstrap'
    id: show-target-build-platforms
  - name: gcr.io/cloud-builders/docker
    args:
      - buildx
      - build
      - '--platform'
      - $_DOCKER_BUILDX_PLATFORMS
      - '-t'
      - 'gcr.io/$PROJECT_ID/hello-world:latest'
      - '--push'
      - .
    id: build-multi-architecture-container-image
options:
  env:
    - DOCKER_CLI_EXPERIMENTAL=enabled
substitutions:
  _DOCKER_BUILDX_PLATFORMS: 'linux/amd64,linux/arm64'

The above configuration creates the pipeline to set up the build environment (initialize-qemu, create-builder, select-builder, and show-target-build-platforms steps), to build a multi-arch container image and to push it to the Container Registry on Google Cloud Platform (build-multi-architecture-container-image step).

To push to another container registry (e.g. Docker Hub) update the build-multi-architecture-container-image step accordingly.

Please consult the Cloud Build documentation to get the information on how to trigger builds (manually or automatically).

GitHub Actions

If you prefer to use GitHub Actions instead of Cloud Build, it is also possible.

The pipeline configuration to build multi-arch container images is the following:

name: ci
on:
  push:
jobs:
  buildx:
    runs-on: ubuntu-latest
    steps:
      - name: checkout code
        uses: actions/checkout@v2
      - name: setup qemu
        uses: docker/setup-qemu-action@v1
      - name: setup buildx
        id: buildx
        uses: docker/setup-buildx-action@v1
      - name: available platforms
        run: echo ${{ steps.buildx.outputs.platforms }}
      - name: login to docker hub
        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_TOKEN }}
      - name: build the image
        run: |
          docker buildx build \
          --push \
          --tag ${{ secrets.DOCKER_USERNAME }}/hello-world:latest \
          --platform linux/amd64,linux/arm64 .

To make it work you need to set up some secrets on GitHub:

DOCKER_USERNAME — your user name on Docker Hub
DOCKER_TOKEN — your Docker Hub access token

Conclusion

That was the last post in the series, and to sum up let's repeat the key points on how to prepare an application for M1 (Apple Silicon):

Use Go to easily build applications for different operating systems
Build multi-arch container images with docker buildx
Utilize Cloud Build or GitHub Action to automate builds

Multi-CPU architecture container images. How to build and push them on Docker Hub (or any other registry)

Petr Razumov — Wed, 02 Jun 2021 12:09:09 +0000

This is the second post in the series on how we prepared our application to run on M1 (Apple Silicon).

In the previous part we were talking about Go programming language and its ability to easily cross-compile applications for different operating systems and CPU architectures using just a developer's laptop.

With this post, I'm going to describe some other aspects of modern cross-platform applications development.

Our application

It's worth repeating that at Tidal Migrations we build our CLI application — Tidal Tools — to make it easier for our customers to deal with all sorts of data necessary on their way towards the clouds. Tidal Migrations' May 2021 Newsletter describes Tidal Tools as the

meat-and-potatoes of how you’ll start your cloud journey.

The CLI app could be run anywhere:

Locally

on Microsoft Windows
on Apple macOS (Intel or M1)
on GNU/Linux

Or preinstalled on a free cloud VM in:

Tidal Tools architecture in brief

Tidal Tools is a Go command-line interface (CLI) application. It mostly acts as a Tidal Migrations API client accompanying our web application. It also has some additional features like source code and database analysis.

Those two extra functionalities are implemented by our technological partners in other programming languages.

We build Docker container images for such 3rd-party solutions and our application (Tidal Tools) runs containers under the hood using the awesome Docker Go SDK.

Problems with container images

While preparing a new release of Tidal Tools for M1 Macs we discovered that our existing Docker container images won't work on the new Apple Silicon architecture. After some investigation we figured out that we build our container images for amd64 architecture, while M1 Macs expect images for arm64 CPU architecture.

Docker images can support multiple architectures, which means that a single image may contain variants for different architectures, and sometimes for different operating systems, such as Windows.

When running an image with multi-architecture support, docker automatically selects the image variant that matches your OS and architecture.

After some trial and error with our Docker images we are now finally confident in our happy path on how to build multi-CPU architecture Docker container images. In other words, we now know how to build container images for different architectures and push such images to container registries (e.g. Docker Hub) to be used on machines with different OSes and architectures. In short, build on (for example) Debian GNU/Linux — run on (for example) macOS for M1!

So, without further delay, let's jump straight to the topic!

How to build multi-arch container images with `docker buildx`

CAUTION! To build container images with multi-CPU architecture support, you need to use parent image which supports multiple CPU architectures. Most of the official images on Docker Hub provide a variety of architectures. For example, the openjdk image variants (which we're going to use later) support arm64v8 and amd64.

For this example, we're going to use “Hello world” application written in Java:

// HelloWorld.java

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}

Let's start with a Dockerfile:

# Dockerfile

FROM openjdk:8-jdk-slim AS builder
COPY HelloWorld.java /app/
WORKDIR /app
RUN javac HelloWorld.java

FROM openjdk:8-jre-slim
COPY --from=builder /app/HelloWorld.class /app/
WORKDIR /app
CMD ["java", "HelloWorld"]

To make it possible to build multi-CPU architecture container images we need to install Docker Buildx. Docker Buildx is a CLI plugin that extends the docker command with some additional features, and multi-arch builds is one of those. If you're using recent Docker Desktop or Docker for Linux packages chances are high that Buildx is already available for you. If not, check the installation instructions.

Create and switch to using a new builder which gives access to the new multi-architecture features:

docker buildx create --name mybuilder --use

docker login

Build and push multi-arch container image for x86-64 (amd64) and AArch64 (arm64) CPU platforms (replace your-username with the actual Docker registry user name):

docker buildx build . \
  --platform linux/arm64,linux/amd64 \
  --tag your-username/hello-world:latest \
  --push

Running the above commands would build and push multi-arch container images to your Docker Hub profile:

When running such image with multi-architecture support, docker automatically selects the image variant that matches the running OS and architecture.

That's it! With this simple trick you can build Docker container images for different operating systems and architectures and host such images on Docker Hub.

I hope you enjoyed this post! Stay tuned to learn more about how we prepared our application to run on M1 (Apple Silicon)!

How to cross-compile Go app for Apple Silicon (M1)

Petr Razumov — Thu, 27 May 2021 19:41:17 +0000

This is the first part in the series on how we prepared our application to run on M1 (Apple Silicon).

At Tidal Migrations we build our CLI application — Tidal Tools — to make it easier for our customers to deal with all sorts of data necessary for their cloud migrations journey. The CLI app could be run anywhere — on a manager’s Microsoft Windows workstation, on a developer’s Apple MacBook Pro, or even on a Linux server since a long time ago in a datacenter far, far away… Because of this, having the ability to build the app for different operating systems was the top priority for us since the beginning of the development. That’s why we choose Go programming language for our CLI application development.

Go (sometimes referred as Golang) is a statically typed, compiled programming language designed at Google. Among other awesome features of Go, there is one which was crucial for us — the ability to cross-compile code for different operating systems and architectures. In other words, it is possible for a developer running, for example, macOS on her laptop to build an application suitable for running on Windows or Linux, or any other operating system which is supported by the Go compiler.

The following short walkthrough will guide you through the process of creating a simple Hello world application and building it for Linux, Windows and macOS on M1.

Let’s start with writing the actual code for our application:

// hello.go

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Printf(
        "Hello world from %s/%s\n",
        runtime.GOOS,
        runtime.GOARCH,
    )
}

If we build it (with go build hello.go command) and run the binary (./hello) it should display something like the following:

Hello world from linux/amd64

Hello world from windows/amd64

Hello world from darwin/arm64

That depends on the OS and architecture of the computer where we build our app. But as I mentioned earlier, it is possible to build Go applications for operating systems and architectures different than the one where we run the build process. With modern Go tools it is pretty straightforward. All we need to do is to set some specific environment variables — GOOS and GOARCH — and voilà, we build binaries for different operating systems and architectures.

At first, let's build our “Hello world” app for Microsoft Windows:

GOOS=windows GOARCH=amd64 go build hello.go

If we run ls, we'd see that a new file (hello.exe) appeared in the current directory:

$ ls
hello.exe  hello.go

Let's determine a type of the hello.exe file using file command:

$ file hello.exe
hello.exe: PE32+ executable (console) x86-64 (stripped to external PDB), for MS Windows

Now, let's build our application for some old (32-bit) Linux:

GOOS=linux GOARCH=386 go build -o hello-linux-386 hello.go

A new file (hello-linux-386) should appear:

$ ls
hello.exe  hello.go  hello-linux-386

And it should be of 32-bit executable type:

file hello-linux-386 
hello-linux-386: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, ..., not stripped

And finally, let's build the same application for Apple Silicon:

GOOS=darwin GOARCH=arm64 go build -o hello-macos-arm64 hello.go

Running that go build command should create the third binary in our folder:

$ ls
hello.exe  hello.go  hello-linux-386  hello-macos-arm64

The type of the file is the following:

$ file hello-macos-arm64 
hello-macos-arm64: Mach-O 64-bit arm64 executable, flags:<|DYLDLINK|PIE>

That's it! With this simple trick you can build Go applications for different operating systems and architectures on your laptop or a single build server.

I hope you enjoyed this post! Stay tuned to learn more about our journey towards M1 version release!

Use Nmap for faster discovery in Cloud Migrations

Mario Mejia — Thu, 25 Mar 2021 21:41:37 +0000

When starting a cloud migration project, one of the most important and often challenging parts is to have an accurate understanding of what you are trying to migrate. Over time, companies start new projects, which means creating new infrastructure, adding servers, databases, etc. This is a normal part of the development cycle. However, despite best efforts, inventories get out of sync.

“We have 5 inventories and lists of servers, but we don’t trust any of them.”

Imagine this simple scenario where a database needs to be migrated from location A to location B. After it is done, the old database in location A must be decommissioned and the infrastructure inventory must be updated. It is not uncommon, that after the migration is finished, the inventory - a CMDB, ops tool or often: an excel file - is adjusted to add the new server and database instance, but no one ever removes the old database from the source inventory.

Now imagine that type of change occurring many times over the years and it doesn’t take long to realize why people don’t trust their inventory. Inventory is increasingly becoming ephemeral.

Solution

At Tidal Migrations, we empower companies to drive faster cloud migrations with rapid discovery and assessment of their application portfolio. In addition to our own tools, people can use 3rd party tools that they might already have installed via Tidal Migrations API integrations. Today, people can also leverage the widely used Nmap utility to perform exhaustive host discovery and reconcile their infrastructure inventory.

What is Nmap?
Nmap is a free and open-source network scanner used by security researchers, network administrators, and migration experts alike. It can be used to discover services running on single hosts, as well as vast networks that contain hundreds of thousands of devices across a multitude of subnets.

Nmap scans a network by sending packets to system network ports, then it analyzes their responses to figure out what ports are open, closed, or filtered by a firewall. As a result, Nmap can identify devices and services running on a network without you needing to deploy agents or request permissions to servers via SSH or WinRM, etc.

In addition to infrastructure reconciliation, scanning your network with Nmap can alert you to known security vulnerabilities. For example, it might identify older software that can be exploited by bad actors, as well as providing you with an opportunity to close open ports that shouldn’t be accessible in the first place.

At Tidal Migrations, we have built capabilities to leverage the output generated by Nmap and send it to our Platform where our users can assess their data, update their inventory, and facilitate their cloud migration journey.

Nmap integrates directly with Tidal Migrations to help you on getting an accurate inventory for your cloud migration project.

How to Use Nmap

You can find the official binary packages for all major operating systems (Linux, Windows, Mac OS) at Nmap’s website, and while there is a GUI option to download, here we will cover how to use the CLI version together with Tidal Migrations.

Nmap offers a wide range of scanning utilities, such as port scanning, host discovery, service version detection to name a few. The documentation is very extensive and easy to follow.

Once Nmap has been installed, you can run nmap -h at the command prompt at any time. It will display your current version, as well as a breakdown of its commands.

Its command structure is as follows:

nmap [ <Scan Type> ...] [ <Options> ] { <target specification> }

Nmap has sensible defaults, so the most basic command will yield results right away. Simply provide a target, single IP, hostname or a range of IPs:

nmap 192.168.1.1-254

A common scan type is Host Discovery via ICMP Echo (aka “ping”). To do this, you can use -sn to disable port scanning:

nmap -sn 192.168.1.0/24              # Ping sweep a subnet

And if you’re curious about how your range expressions are evaluated, you can use -sL to list targets only, without scanning them at all:

nmap -sL 192.168.1.1-3,10-20         # No Scan. List targets only

To say there are a lot of scan types you can run using Nmap is an understatement. In addition to the built-in flags, there is also an entire ecosystem of extensions and plugins that scanning experts employ in those hard to scan environments. To keep this blog from becoming War and Peace, I will share two of my favorite commands to get you started right away.

nmap -T2 192.168.1.0-127

-T - Timing mode. Adjusting the frequency of packets being sent can be used to evade or comply with some of the rules in firewalls or IDS.
When running Nmap in timing mode, you must use either "Paranoid", "Sneaky", "Polite", "Normal", "Aggressive", "Insane" or a number from 0 (Paranoid) being the slowest, waiting 5 minutes between sending each probe to 5 (Insane) which will be easily detectable.

To more efficiently scan your network, limit yourself to the known ports for common web applications and databases. Also, save your output as XML so you can incorporate the results into your migration planning.

nmap -sS -p80,443,8080,8443,1433,1521,27017 10.0.0.0/24 -oX my_network_scan.xml

-sS - enables TCP SYN Stealth port scan.
-p - lets you specify the ports you are interested in, therefore improving your scan speed.
-oX - generates an XML file with the output of the scan.

It is possible to combine a Nmap command and our Tidal Migration integration in just one step.

Let’s break this example into two parts.
To start, Nmap is going to scan an IP Address and its range, the -sV flag indicates Service and Version detection on open ports, and -oX declares that we want the output in XML format.
After the scan is completed, our CLI Tidal Tools will pick up the output and send it to your Tidal Migrations account where you can continue your discovery process.

Summary

Whether you are migrating to the cloud today or just preparing your infrastructure for a future shift. Having a solid understanding of your current inventory and infrastructure is a must.

After this brief introduction to Nmap, its capabilities, and how to use it, I hope you feel encouraged to use this tool in your cloud migration journey. There is plenty of information on its official website, and a strong community backing it up.

Happy discovery :)

-Mario Mejia
Senior Software Engineer, Tidal Migrations

Want to know more about Tidal Migrations?
Tidal Migrations is a cloud migration tool that gives you this application inventory, discovery, and assessment all in one place. Delivered as a SaaS platform, you can import your spreadsheets or deploy our tools and get moving today. Results in minutes, not months. Migrate with confidence.

DEV Community: Tidal

Interactive CLI prompts in Go

Tidal Migrations 💓 CLI applications

Passing data to CLI apps

How to implement text input prompt

How to implement password input prompt

How to implement Yes/No prompt

How to implement interactive checkboxes

Caveats and workarounds

Libraries

AlecAivazis / survey

A golang library for building interactive and accessible prompts with full support for windows and posix terminals.

Survey

Songmu / prompter

golang utility for easy prompting

prompter

Description

Synopsis

Features

License

Author

manifoldco / promptui

Interactive prompt for command-line applications

promptui

Overview

Basic Usage

Prompt

Conclusion

Automating multi-arch container images builds (we used Google Cloud Build but GitHub Actions would also work)

Cloud Build

GitHub Actions

Conclusion

Multi-CPU architecture container images. How to build and push them on Docker Hub (or any other registry)

Our application

Tidal Tools architecture in brief

Problems with container images

How to build multi-arch container images with docker buildx

How to cross-compile Go app for Apple Silicon (M1)

Use Nmap for faster discovery in Cloud Migrations

Solution

How to Use Nmap

Summary

How to build multi-arch container images with `docker buildx`