You must specify a region. You can also configure your region by running “aws configure”.

When we execute an AWS CLI command, we need to supply the AWS Region. If it is not specified, we get the error message:

You must specify a region. You can also configure your region by running “aws configure”.

We can add the region with the –region command line argument, or store it in the ~/.aws/config file.

The format of the ~/.aws/credentials file is

[default]
aws_access_key_id = …
aws_secret_access_key = …

[my-account]
aws_access_key_id = …
aws_secret_access_key = …

The format of the ~/.aws/config file is the following. Make sure to add the word “profile” within the square brackets for every profile you specified in the credentials file, except for the “default” one!!!

[default]
region = us-east-1
output = json

[profile my-account]
region = us-east-1
output = json

x509: certificate signed by unknown authority

I have built a Docker container with a Go application that used the Go AWS SDK. When my program tried to access an S3 bucket I got the error message

RequestError: send request failed
caused by: Get https://MY_BUCKET_NAME.s3.amazonaws.com: x509: certificate signed by unknown authority

To solve the problem I had to add the following line to the Dockerfile

On Ubuntu

RUN apt ca-certificates && rm -rf /var/cache/apk/*

On Alpine

RUN apk update && apk add ca-certificates && rm -rf /var/cache/apk/* 

Docker for Windows cannot start: “Hardware assisted virtualization and data execution protection must be enabled in the BIOS”

To start Docker on Windows, Hyper-V and the Hypervisor has to be enabled on Windows.

  1. Start a PowerShell window as administrator
  2. Enable Hyper-V
    dism.exe /Online /Enable-Feature:Microsoft-Hyper-V /All
  3. Enable the Hypervisor
    bcdedit /set hypervisorlaunchtype auto
  4. Restart the computer

List the Active Directory groups the user is a member of

To list the Active Directory groups where the current user is a member, execute in the PowerShell window

(New-Object System.DirectoryServices.DirectorySearcher("(&(objectCategory=User)(samAccountName=$($env:username)))")).FindOne().GetDirectoryEntry().memberOf

To get the Active Directory groups for another user, replace THE_USER_NAME with the Active directory user name of the person.

(New-Object System.DirectoryServices.DirectorySearcher("(&(objectCategory=User)(samAccountName=THE_USER_NAME))")).FindOne().GetDirectoryEntry().memberOf

Debugging Go programs in Atom

To be able to debug Go programs in Atom, make sure the Go IDE is installed. See Install the Go IDE at Install and set up Go

To start debugging select the Debugger tab in the upper right corner of Atom

If you get the error message: The debugger is not attached, and when you click Attach debugger you get the error message: No debuggers installed, look for available debuggers on atom.io/packages

Check if the go-debug Atom package is installed

  • Open the Settings page from the File menu
  • Select Install on the left side
  • Search for go-debug
  • If the package is not installed, click the Install button

If you still get the same error message, download the go-delve package.

Visit https://github.com/derekparker/delve/tree/master/Documentation/installation for more info.

  • In the terminal window execute
    go get -u github.com/go-delve/delve/cmd/dlv
  • Restart Atom for the change to take effect.

 To debug your Go application

  • Click the Debugger tab in the upper right corner, and select the Debug config
  • To set a breakpoint, click the line in the program and press the F9 key. A red circle appears on the margin. 
  • The breakpoint appears on the right side of the screen too
  • Press F5 to run the application in the debugger
  • When the breakpoint is hit the toolbar on the right side shows the Stacktrace and the Variables. Click the arrow to open the section.
  • Click the arrow next to the variable name to show more details

Using Go packages

To use a public package in your Go application add the line to the top of your program to import the package

import "github.com/aws/aws-sdk-go/service/s3"

If this is the first time you are using the package, the error message appears in the output window of Atom when you save the file

cannot find package “github.com/aws/aws-sdk-go/service/s3” in any of:

C:\Go\src\github.com\aws\aws-sdk-go\service\s3 (from $GOROOT) C:\Users\MY_USERNAME\go\src\github.com\aws\aws-sdk-go\service\s3 (from $GOPATH)

Open a terminal window and execute the command to download the package

go get github.com/aws/aws-sdk-go/service/s3

 

Your first Go application

Programming in GO is quick and fun. You can write a working, compiled application with a few lines of code. In this example, we will use Visual Studio Code to edit the source code, and we have already configured it to start from the command line with the “code” command.

Write your first Go application

Create a directory for your application, let’s call it myapp

mkdir myapp

Open a terminal window in the myapp directory

cd myapp

Initialize the Go Modules. Go modules are available since Go version  1.11, in Go version 1.13 is the default over $GOPATH. In the main directory of your application execute

go mod init github.com/MY_USER_NAME/myapp

When we add an import statement to the code, Go will automatically update the go.mod file to include the dependency with the latest stable version. To list the referenced modules execute

go list -m all

Create a file for your module. This file is not required, but as it is on the top level, the package name is considered to be the name of the module.

code config.go

Enter to code

package myapp

func Config() string {
	return "Application config"
}

Create a sub-directory for the entry point of your application. When someone imports your application as a module this will be the command to execute.

mkdir -p cmd/myapp

Create the file for the command

code cmd/myapp/myapp.go

Create the main function

package main

import (
	"fmt"

	"github.com/MY_USER_NAME/myapp"
)

func main() {
	fmt.Println(myapp.Config())
}

Save the files and run the application

go run cmd/myapp/*

The output should be

Application config

Add a package to the application

mkdir mypackage

Create the package file

code mypackage/mypackage.go

Write the code of the package

package mypackage

func RunMyPackage() string {
	return "MyPackage running"
}

Update the main function to call the new package

code cmd/myapp/myapp.go

Add two lines to the code

package main

import (
	"fmt"

	"github.com/MY_USER_NAME/myapp"
	"github.com/MY_USER_NAME/myapp/mypackage" // NEW LINE
)

func main() {
	fmt.Println(myapp.Config())
	fmt.Println(mypackage.RunMyPackage()) // NEW LINE
}

Save the files and run the application. The output should be

go run cmd/myapp/*

Application config
MyPackage running





Using modules from other applications

To upgrade a module to the latest tagged version for example golang.org/x/text

go get golang.org/x/text

List all available versions of a module, for example, rsc.io/sampler

go list -m -versions rsc.io/sampler

Get a specific version of the module

go get rsc.io/sampler@v1.3.1

To remove unused dependencies from the go.mod and go.sum file

go mod tidy

Set directory access in Windows

When you use SetAccessRule() to set access rights on a Windows directory, the user who will get the permission has to be a member of the Administrators group. If the user is not a member of the Administrators group PowerShell shows the error message

Exception calling “SetAccessRule” with “1” argument(s): “Some or all identity references could not be translated.”