package main

import "fmt"

func main() {
  message := greetMe("world")
  fmt.Println(message)
}

func greetMe(name string) string {
  return "Hello, " + name + "!"
}

$ go run hello.go

var msg string
msg = "Hello"

msg := "Hello"

const Phi = 1.618

str := "Hello"

str := `Multiline
string`

num := 3          // int
num := 3.         // float64
num := 3 + 4i     // complex128
num := byte('a')  // byte (alias for uint8)

var u uint = 7        // uint (unsigned)
var p float32 = 22.7  // 32-bit float

// var numbers [5]int
numbers := [...]int{0, 0, 0, 0, 0}

i := 2
f := float64(i)
u := uint(i)

slice := []int{2, 3, 4}

slice := []byte("Hello")

if day == "sunday" || day == "saturday" {
  rest()
} else if day == "monday" && isTired() {
  groan()
} else {
  work()
}

if _, err := doThing(); err != nil {
  fmt.Println("Uh oh")

switch day {
  case "sunday":
    // cases don't "fall through" by default!
    fallthrough

  case "saturday":
    rest()

  default:
    work()
}

for count := 0; count <= 10; count++ {
  fmt.Println("My counter is at", count)
}

entry := []string{"Jack","John","Jones"}
for i, val := range entry {
  fmt.Printf("At position %d, the character %s is present\n", i, val)

n := 0
x := 42
for n != x {
  n := guess()
}

if day == "sunday" || day == "saturday" {
  rest()
} else if day == "monday" && isTired() {
  groan()
} else {
  work()
}

if _, err := doThing(); err != nil {
  fmt.Println("Uh oh")

# Generate a new SSH key pair (without passphrase for automation)
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
# Copy public key to the remote server
ssh-copy-id user@remote_host

# Encrypt
openssl enc -aes-256-cbc -salt -in myfile.txt -out myfile.txt.enc
# Decrypt
openssl enc -aes-256-cbc -d -in myfile.txt.enc -out myfile.txt

# List all firewall rules
sudo iptables -L -v -n
# Save current firewall rules
sudo iptables-save > /etc/iptables/rules.v4

# View the latest entries in syslog
tail -f /var/log/syslog
# Or, for more specific logs, use:
journalctl -xe

sudo iftop  # Needs to be installed; visualizes incoming/outgoing traffic by host

# List all listening ports and their associated services
sudo netstat -tuln
# Or, using `ss` (faster on modern Linux distributions)
sudo ss -tuln

#!/bin/bash
# backup.sh
SOURCE_DIR="/path/to/source"
DEST_DIR="/path/to/destination"
DATE=$(date +'%Y%m%d')
tar -czvf "${DEST_DIR}/backup_${DATE}.tar.gz" "$SOURCE_DIR"

sudo apt update && sudo apt upgrade -y
sudo apt autoremove -y && sudo apt clean

# Summary of disk space usage for each filesystem
df -h
# List folder sizes in the current directory
du -sh *

top
# Or, for a summary
htop  # Provides a better interface if available

# Limit CPU usage to 50% and memory to 256MB
docker run -d --name limited_container --cpus=".5" --memory="256m" myimage

# Check disk usage of files in a running container
docker exec -it container_name du -h /path/to/dir

# Use a multi-stage build to reduce image size
FROM golang:1.19 AS builder
WORKDIR /app
COPY . .
RUN go build -o main .

FROM alpine:latest
WORKDIR /root/
COPY --from=builder /app/main .
CMD ["./main"]

# Remove unused images, containers, networks, and volumes
docker system prune -a

# Monitor resource usage statistics for containers
docker stats

# Scale a deployment to 3 replicas
kubectl scale deployment my-deployment --replicas=3

# Start a debugging session in a running Pod
kubectl exec -it pod-name -- /bin/sh

# Sample Kubernetes Job configuration
apiVersion: batch/v1
kind: Job
metadata:
  name: example-job
spec:
  template:
    spec:
      containers:
      - name: example
        image: busybox
        command: ["echo", "Hello Kubernetes"]
      restartPolicy: Never

# Check resource usage for nodes and namespaces
kubectl top nodes
kubectl top pods --namespace=my-namespace

# Update the image version for a deployment with zero downtime
kubectl set image deployment/my-deployment my-container=myimage:v2