DEV Community: Tirumal Rao

Configuring kubectl for Minikube Access

Tirumal Rao — Fri, 12 Apr 2024 09:41:47 +0000

I attempted to connect to Minikube running on an Ubuntu Desktop from my Mac. Here is how I did it.

When you're working with Kubernetes via Minikube, properly configuring kubectl—the Kubernetes command-line client—is crucial for managing your clusters. This guide will walk you through setting up kubectl to communicate with Minikube, focusing on specifying the server address, setting up authentication, and defining the active context.

Step 1: Set the Cluster

To set the cluster details in kubectl, you need to specify the server's URL and provide the certificate authority (CA) data to ensure secure communication. This can be done using the following command:

kubectl config set-cluster minikube --server=https://192.168.49.2:8443 --certificate-authority=ca.crt --embed-certs=true

--server: This is the URL to your Minikube Kubernetes API server.
--certificate-authority: This is the path to the CA certificate, which kubectl uses to verify the server's certificate.
--embed-certs=true: This option tells kubectl to embed the certificate data directly into the kubeconfig file, making the configuration portable.

Obtaining the Certificate Authority File
The ca.crt file is typically created when Minikube sets up its Kubernetes environment. You can find this file within the .minikube directory located in your home directory (e.g., ~/.minikube/ca.crt).

Step 2: Set the Credentials

Setting credentials involves specifying the client certificate and key files used to authenticate with Kubernetes:

kubectl config set-credentials minikube --client-certificate=client.crt --client-key=client.key --embed-certs=true

--client-certificate and --client-key: These are paths to your client certificate and key files, respectively.
--embed-certs=true: Similar to the cluster setup, this embeds the certificates in the kubeconfig file

Locating Your Client Certificates
The client.crt and client.key files are also typically located in the .minikube directory. You should check this directory for files named similarly, possibly under a certs subdirectory (e.g., ~/.minikube/profiles/minikube/client.crt).

Step 3: Set the Context

A context in kubectl ties together a cluster and its credentials. Set the context for Minikube using:

kubectl config set-context minikube --cluster=minikube --user=minikube

This command configures kubectl to use the specified cluster and user (credentials) for the 'minikube' context. You can switch to this context using:

kubectl config use-context minikube

This command activates the 'minikube' context, and all subsequent kubectl commands will interact with your Minikube cluster.

If you encounter issues connecting to Minikube on a different computer within the same network, refer to this previous article for solutions.

How to Troubleshoot Connectivity Issues with Minikube on Docker

Conclusion

Configuring kubectl with the correct cluster settings, credentials, and context is essential for managing your Kubernetes clusters efficiently. By setting these parameters carefully, you ensure that your interactions with Kubernetes via kubectl are secure and correctly targeted at your Minikube instance.

Once these settings are in place, you're ready to manage your Kubernetes cluster, deploy applications, and monitor their performance directly from your command line.

How to Troubleshoot Connectivity Issues with Minikube on Docker

Tirumal Rao — Fri, 12 Apr 2024 08:23:57 +0000

When working with Kubernetes through Minikube, especially when hosted via Docker on an Ubuntu machine, networking issues can sometimes be daunting. One common problem is when you can't ping or access Minikube from another device on the same physical network, like a Mac. This article will guide you through troubleshooting and resolving such issues, ensuring your development environment is as connected as you need it to be.

Understanding the Network Setup

Before diving into troubleshooting, it's crucial to understand the network setup, particularly how Docker and Minikube configure their networks. Typically, Docker creates virtual networks that Minikube uses to operate its clusters. These networks might not be automatically accessible outside the host machine, depending on how they're configured.

For instance, if your Minikube VM has an IP address on a subnet different from your host machine's primary subnet, devices on your network might not be able to route to Minikube directly.

Common Network Configurations:

Bridge Network: Docker often uses a bridge network to connect containers. If Minikube is running on this network, it will have an IP address on a virtual subnet.
Host Network: When configured to use the host network, Minikube and other containers will share the host's IP address, making connectivity easier but less secure.

Initial Troubleshooting Steps

Check Minikube’s IP Address: Use minikube ip to confirm the IP and ensure it matches the subnet you're expecting.
Ping from the Host: Before testing external connectivity, verify that the host machine can ping Minikube.
Inspect Docker Networks: Using docker network ls and docker network inspect, you can find details about the network configurations being used.

Advanced Troubleshooting and Solutions

When basic checks fail, you might need to implement more complex solutions, such as configuring routing or adjusting network settings.

Configure Routing

If your host (Ubuntu) and Minikube are on different subnets, you may need to configure your Ubuntu machine to route traffic properly between these networks.

Steps to Enable IP Forwarding on Ubuntu:

Edit /etc/sysctl.conf and add or uncomment the line net.ipv4.ip_forward=1.
Apply the settings with sudo sysctl -p.

Adding Static Routes on Mac:

Use the command sudo route -n add 192.168.49.0/24 192.168.1.15 to route traffic to the Minikube subnet via the Ubuntu host.

Verify the Route:

Check if the route has been added correctly on your Mac. You can do this by listing the routing table:

netstat -nr

Look for the entry 192.168.49.0/24 and confirm that it is set to route through 192.168.1.15.

To delete the route

sudo route -n delete 192.168.49.0/24 192.168.1.15

Adjust Docker Network Configuration

Modifying Docker's default network configuration can help bridge the connectivity gap. You might need to create a custom network bridge that better suits your network topology.

Using VPN or Tunnels

Setting up a VPN or SSH tunnel can help securely bridge the network between your Mac and the Ubuntu host, allowing for seamless connectivity to Minikube.

Conclusion

Networking issues in Docker and Minikube can stem from a variety of sources, but they're usually solvable through careful configuration of network settings, routing, and sometimes more advanced solutions like VPNs. By understanding how these technologies interact with your network, you can ensure a smooth and accessible development environment.

Golang Interview Questions (Problem Solving)

Tirumal Rao — Tue, 12 Sep 2023 03:02:53 +0000

Following are problem solving interview questions. Practice each solution, most of them are self explainatory.

1. Find the Maximum of Two Numbers

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

2. Factorial of a Number

func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}

3. Fibonacci Sequence

func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

4. Check for Prime Number

Optimizing Prime Checks with Go (Golang)

5. Slice Reverse

func reverseSlice(s []int) []int {
    length := len(s)
    for i := 0; i < length/2; i++ {
        s[i], s[length-i-1] = s[length-i-1], s[i]
    }
    return s
}

6. Find Element in Slice

func findElement(s []int, el int) int {
    for i, v := range s {
        if v == el {
            return i
        }
    }
    return -1
}

7. Check Palindrome String

func isPalindrome(s string) bool {
    for i := 0; i < len(s)/2; i++ {
        if s[i] != s[len(s)-i-1] {
            return false
        }
    }
    return true
}

8. Find the Smallest Number in a Slice

func findMin(s []int) int {
    min := s[0]
    for _, v := range s {
        if v < min {
            min = v
        }
    }
    return min
}

9. Count Occurrences of a Character in a String

func countChar(s string, char rune) int {
    count := 0
    for _, c := range s {
        if c == char {
            count++
        }
    }
    return count
}

10. Check If Two Strings Are Anagrams

func areAnagrams(s1, s2 string) bool {
    if len(s1) != len(s2) {
        return false
    }
    charCount := make(map[rune]int)
    for _, char := range s1 {
        charCount[char]++
    }
    for _, char := range s2 {
        charCount[char]--
        if charCount[char] < 0 {
            return false
        }
    }
    return true
}

11. Merge Two Slices

func mergeSlices(s1, s2 []int) []int {
    return append(s1, s2...)
}

12. Square Root Without Using Math Package

func sqrt(n float64) float64 {
    x := n
    z := (x + n/x) / 2
    for z != x {
        x = z
        z = (x + n/x) / 2
    }
    return z
}

13. Bubble Sort

func bubbleSort(nums []int) []int {
    n := len(nums)
    for i := 0; i < n; i++ {
        for j := 0; j < n-i-1; j++ {
            if nums[j] > nums[j+1] {
                nums[j], nums[j+1] = nums[j+1], nums[j]
            }
        }
    }
    return nums
}

14. Binary Search

func binarySearch(nums []int, target int) int {
    low, high := 0, len(nums)-1
    for low <= high {
        mid := (low + high) / 2
        if nums[mid] == target {
            return mid
        }
        if nums[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }
    return -1
}

15. Check Power of Two

func isPowerOfTwo(n int) bool {
    if n <= 0 {
        return false
    }
    return n & (n-1) == 0
}

16. Find Missing Number in 1..n

func findMissingNumber(nums []int) int {
    n := len(nums) + 1
    total := n * (n + 1) / 2
    sum := 0
    for _, num := range nums {
        sum += num
    }
    return total - sum
}

17. Find Intersection of Two Slices

func intersect(s1, s2 []int) []int {
    m := make(map[int]bool)
    var res []int
    for _, num := range s1 {
        m[num] = true
    }
    for _, num := range s2 {
        if m[num] {
            res = append(res, num)
        }
    }
    return res
}

18. Rotate Slice by K Elements

func rotate(nums []int, k int) []int {
    k %= len(nums)
    reverse(nums)
    reverse(nums[:k])
    reverse(nums[k:])
    return nums
}
func reverse(nums []int) {
    for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
        nums[i], nums[j] = nums[j], nums[i]
    }
}

19. Unique Elements in a Slice

func unique(nums []int) []int {
    m := make(map[int]bool)
    var res []int
    for _, num := range nums {
        if !m[num] {
            res = append(res, num)
            m[num] = true
        }
    }
    return res
}

20. Count Vowels and Consonants in a String

func countVowelsConsonants(s string) (int, int) {
    vowels, consonants := 0, 0
    for _, char := range s {
        switch char {
        case 'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U':
            vowels++
        default:
            if (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') {
                consonants++
            }
        }
    }
    return vowels, consonants
}

21. Stack Using Slices

type Stack struct {
    items []int
}
func (s *Stack) Push(item int) {
    s.items = append(s.items, item)
}
func (s *Stack) Pop() int {
    if len(s.items) == 0 {
        return -1
    }
    item, _ := s.items[len(s.items)-1], s.items[:len(s.items)-1]
    return item
}

22. Map Functions on Slice

func mapFunc(nums []int, f func(int) int) []int {
    for i, v := range nums {
        nums[i] = f(v)
    }
    return nums
}

23. Filter Elements in Slice

func filter(nums []int, f func(int) bool) []int {
    var res []int
    for _, v := range nums {
        if f(v) {
            res = append(res, v)
        }
    }
    return res
}

24. Swap Two Numbers Without a Temporary Variable

func swap(a, b int) (int, int) {
    a = a + b
    b = a - b
    a = a - b
    return a, b
}

25. Determine If a String Starts With a Given Substring

func startsWith(s, prefix string) bool {
    return strings.HasPrefix(s, prefix)
}

26. Determine If a String Ends With a Given Substring

func endsWith(s, suffix string) bool {
    return strings.HasSuffix(s, suffix)
}

27. Remove Duplicates From a Slice

func removeDuplicates(nums []int) []int {
    seen := make(map[int]bool)
    result := []int{}
    for _, value := range nums {
        if _, exists := seen[value]; !exists {
            seen[value] = true
            result = append(result, value)
        }
    }
    return result
}

28. Deep Copy a Slice

func deepCopy(nums []int) []int {
    return append([]int(nil), nums...)
}

29. Count Set Bits of an Integer

func countSetBits(n int) int {
    count := 0
    for n != 0 {
        count += n & 1
        n >>= 1
    }
    return count
}

30. Convert Integer to Binary String

func toBinary(n int) string {
    if n == 0 {
        return "0"
    }
    result := ""
    for n > 0 {
        result = strconv.Itoa(n&1) + result
        n >>= 1
    }
    return result
}

31. Find GCD of Two Numbers

func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

32. Check If a Number Is Even or Odd

func isEven(n int) bool {
    return n%2 == 0
}

33. Sum of All Elements in a Slice

func sum(nums []int) int {
    total := 0
    for _, v := range nums {
        total += v
    }
    return total
}

34. Recursive Sum of Digits of a Number

func sumDigits(n int) int {
    if n == 0 {
        return 0
    }
    return n%10 + sumDigits(n/10)
}

35. Find the Second Largest Number in a Slice

func secondLargest(nums []int) int {
    first, second := -1<<63, -1<<63
    for _, num := range nums {
        if num > first {
            first, second = num, first
        } else if num > second {
            second = num
        }
    }
    return second
}

36. Find the Missing Number in a Sequence

Find the missing number in a sequence from 1 to n.

func findMissing(nums []int, n int) int {
    expectedSum := n * (n + 1) / 2
    actualSum := 0
    for _, v := range nums {
        actualSum += v
    }
    return expectedSum - actualSum
}

37. Rotate a Slice

Rotate an integer slice to the right by k steps.

func rotate(nums []int, k int) {
    n := len(nums)
    k = k % n
    reverse(nums, 0, n-1)
    reverse(nums, 0, k-1)
    reverse(nums, k, n-1)
}

func reverse(nums []int, start, end int) {
    for start < end {
        nums[start], nums[end] = nums[end], nums[start]
        start++
        end--
    }
}

38. Count Occurrences of a Character in a String

func countOccurrences(s, char string) int {
    return strings.Count(s, char)
}

39. Find the Majority Element

Find the element that appears more than n/2 times in a slice of size n.
(Boyer-Moore Voting Algorithm)

func majorityElement(nums []int) int {
    count, candidate := 0, 0
    for _, num := range nums {
        if count == 0 {
            candidate = num
        }
        if num == candidate {
            count++
        } else {
            count--
        }
    }
    return candidate
}

40. Flatten a Nested Slice of Integers

Given a nested slice of integers, flatten it.

func flatten(nested [][]int) []int {
    var flat []int
    for _, inner := range nested {
        flat = append(flat, inner...)
    }
    return flat
}

41. Find Intersection of Two Slices

func intersection(nums1, nums2 []int) []int {
    set := make(map[int]bool)
    result := make(map[int]bool)
    for _, num := range nums1 {
        set[num] = true
    }
    for _, num := range nums2 {
        if set[num] {
            result[num] = true
        }
    }
    var res []int
    for num := range result {
        res = append(res, num)
    }
    return res
}

42. Find the First Unique Character in a String

func firstUniqChar(s string) int {
    count := make(map[rune]int)
    for _, ch := range s {
        count[ch]++
    }
    for i, ch := range s {
        if count[ch] == 1 {
            return i
        }
    }
    return -1
}

43. Implement strStr()

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

func strStr(haystack, needle string) int {
    l, r := len(haystack), len(needle)
    for i := 0; i <= l-r; i++ {
        if haystack[i:i+r] == needle {
            return i
        }
    }
    return -1
}

44. Check If All Characters in a String Are Unique

func isUnique(s string) bool {
    chars := make(map[rune]bool)
    for _, ch := range s {
        if chars[ch] {
            return false
        }
        chars[ch] = true
    }
    return true
}

45. Count Number of Words in a String

func countWords(s string) int {
    words := strings.Fields(s)
    return len(words)
}

46. Convert String to Integer (without using the built-in parsing functions)

func strToInt(s string) (int, error) {
    if len(s) == 0 {
        return 0, errors.New("empty string")
    }
    i, sign, res := 0, 1, 0
    if s[0] == '-' {
        sign = -1
        i++
    }
    for ; i < len(s); i++ {
        if s[i] < '0' || s[i] > '9' {
            return 0, errors.New("invalid character in string")
        }
        res = res*10 + int(s[i]-'0')
    }
    return sign * res, nil
}

47. Find Smallest and Largest Number in a Slice

func minMax(nums []int) (int, int) {
    if len(nums) == 0 {
        return 0, 0
    }
    min, max := nums[0], nums[0]
    for _, v := range nums {
        if v < min {
            min = v
        }
        if v > max {
            max = v
        }
    }
    return min, max
}

48. Merge Two Sorted Lists

Merge two sorted slices of integers into a new sorted slice.

Explanation: The function uses two pointers to compare elements in both slices. The smaller value between the two pointers is added to the result slice and the corresponding pointer is moved to the next position.

func mergeSortedLists(nums1 []int, nums2 []int) []int {
    i, j := 0, 0
    var result []int

    for i < len(nums1) && j < len(nums2) {
        if nums1[i] <= nums2[j] {
            result = append(result, nums1[i])
            i++
        } else {
            result = append(result, nums2[j])
            j++
        }
    }

    // Add remaining elements from nums1 (if any)
    for i < len(nums1) {
        result = append(result, nums1[i])
        i++
    }

    // Add remaining elements from nums2 (if any)
    for j < len(nums2) {
        result = append(result, nums2[j])
        j++
    }

    return result
}

49. Remove Duplicates from Slice

Remove duplicates from an integer slice without using any additional data structures.

Explanation: The solution below uses the idea of maintaining two pointers. One, i, is used to iterate over the array, and the other, j, keeps track of the position where the next unique element should be placed.

func removeDuplicates(nums []int) []int {
    if len(nums) == 0 {
        return nums
    }
    j := 0
    for i := 1; i < len(nums); i++ {
        if nums[i] != nums[j] {
            j++
            nums[j] = nums[i]
        }
    }
    return nums[:j+1]
}

50. Find the Longest Substring Without Repeating Characters

Given a string, find the length of the longest substring without repeating characters.

Explanation: Use a sliding window approach. Maintain a start of the window and use a map to keep track of the characters and their latest positions. When a character repeats, update the start of the window.

func lengthOfLongestSubstring(s string) int {
    charIndex := make(map[rune]int)
    maxLength, start := 0, 0

    for i, ch := range s {
        // If the character is already in the map and its index is equal or larger than the current start
        if idx, exists := charIndex[ch]; exists && idx >= start {
            start = idx + 1
        }
        charIndex[ch] = i
        if i-start+1 > maxLength {
            maxLength = i - start + 1
        }
    }

    return maxLength
}

51. Implement Binary Tree (Bonus Question)

package main

import "fmt"

type Node struct {
    Data  int
    Left  *Node
    Right *Node
}

type BinaryTree struct {
    Root *Node
}

func (t *BinaryTree) Insert(data int) {
    if t.Root == nil {
        t.Root = &Node{Data: data}
        return
    }

    insert(t.Root, data)
}

func insert(node *Node, data int) {
    if node == nil {
        return
    }

    if data < node.Data {
        if node.Left == nil {
            node.Left = &Node{Data: data}
            return
        }
        insert(node.Left, data)
    } else {
        if node.Right == nil {
            node.Right = &Node{Data: data}
            return
        }
        insert(node.Right, data)
    }
}

func (t *BinaryTree) InOrderTraversal() {
    inOrder(t.Root)
}

func inOrder(node *Node) {
    if node == nil {
        return
    }

    inOrder(node.Left)
    fmt.Println(node.Data)
    inOrder(node.Right)
}

func main() {
    tree := &BinaryTree{}

    values := []int{2, 3, 50, 20, 30, 4, 5, 8, 1}

    for _, v := range values {
        tree.Insert(v)
    }

    fmt.Println("In order Traversal")
    tree.InOrderTraversal()
}

Explanation:

Struct Definitions:
- Node: Represents a node of the binary tree. It has a Data field (integer), a pointer to the Left child node, and a pointer to the Right child node.
- BinaryTree: Represents the tree itself with a pointer to its root node.
Insertion Method:
- (t *BinaryTree) Insert(data int): This is a method on the BinaryTree struct that takes an integer and inserts it into the tree.
- If the tree's root is nil (empty), it sets the root to be a new node with the provided data.
- Otherwise, it calls the helper function insert to insert the data recursively.
- insert(node *Node, data int): This is a recursive function that inserts a value into the tree. Depending on the value relative to the current node's data, it either goes left (smaller values) or right (larger values).
In-Order Traversal Method:
- t *BinaryTree) InOrderTraversal(): This method on the BinaryTree struct does an in-order traversal of the tree, printing out node data in the process.
- It calls the helper function inOrder to perform the traversal.
- inOrder(node *Node): This is a recursive function that performs an in-order traversal of the tree. This means it visits the left subtree, prints the current node's data, and then visits the right subtree.
main Function:
- A new instance of the binary tree is created.
- Values are inserted into the tree using the provided slice of integers.
- The tree is then traversed in-order, printing the values.

Optimizing Prime Checks with Go (Golang)

Tirumal Rao — Tue, 12 Sep 2023 02:14:08 +0000

The efficiency of the prime-checking algorithm can be improved by only checking for divisibility up to the square root of the number, as any factor larger than that would necessarily pair with a factor smaller than the square root. Here's a more efficient version of the isPrime function:

package main

import (
    "fmt"
    "math"
)

func isPrime(n int) (bool, string) {
    // 0 and 1 are not prime
    if n == 0 || n == 1 {
        return false, fmt.Sprintf("%d is not prime, by definition!", n)
    }

    // negative numbers are not prime
    if n < 0 {
        return false, "Negative numbers are not prime, by definition!"
    }

    // Special case: 2 is prime
    if n == 2 {
        return true, fmt.Sprintf("%d is a prime number!", n)
    }

    // Any even number other than 2 is not prime
    if n%2 == 0 {
        return false, fmt.Sprintf("%d is not a prime number because it is divisible by 2", n)
    }

    // Check only up to the square root of n and only check odd divisors
    sqrtN := int(math.Sqrt(float64(n)))
    for i := 3; i <= sqrtN; i += 2 {
        if n%i == 0 {
            return false, fmt.Sprintf("%d is not a prime number because it is divisible by %d", n, i)
        }
    }

    return true, fmt.Sprintf("%d is a prime number!", n)
}

func main() {
    // Example usage
    num := 29
    isPrimeNum, msg := isPrime(num)
    fmt.Println(msg)
}

Key Points:

Checking only up to square root of n: After considering the special cases, the loop only checks divisibility for numbers up to sqrt(n).
Skipping even numbers: Since we've already checked for n = 2 as a special case, and any other even number will be divisible by 2 and hence not prime, we can safely start the loop at 3 and increment by 2. This way, we only check odd numbers as potential divisors.

FAQ: Why Checking only up to square root of `n`?

The reasoning for checking only up to the square root of n when determining if n is prime is based on the properties of factors.

Imagine if n is divisible by a number x which is greater than the square root of n. Then, there must also be another number y such that: X x Y = n

Now, since x is greater than the square root of n, y must be smaller than the square root of n for their product to be n. Think of it this way: if both x and y were greater than the square root of n, their product would exceed n. Similarly, if both were less than the square root of
n, their product would be less than n.

So, if n has a factor greater than its square root, it will also have a factor smaller than its square root. This is why, to determine if n is prime, we only need to check for factors up to and including its square root. If we haven't found any factors in that range, then n doesn't have any factors and is therefore prime.

To illustrate, let's use a number, say n=100. The square root of 100 is 10. If n has a factor greater than 10 (like 20), it will necessarily have a corresponding factor smaller than 10 (like 5, since 20 x 5 = 100). By checking up to 10, we'll catch the factor of 5, so we don't need to check factors greater than 10.

Implementing the Repository Pattern in Go (Golang)

Tirumal Rao — Sat, 09 Sep 2023 16:05:16 +0000

The Repository Pattern is a commonly used pattern in software architecture that abstracts the data access logic for an application. It promotes a cleaner separation of concerns, making the application more maintainable, scalable, and testable.

When applied to Go (or "Golang"), the Repository Pattern provides a straightforward way to abstract the access to your data source, which could be a database, a web service, or even a file system. Here's a brief overview of how you can implement it:

1. Define your domain model:

// models/user.go
package models

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
}

2. Define the Repository interface:

This interface will outline the methods that your repository must implement.

// repository/user_repository.go
package repository

import "your_package_path/models"

type UserRepository interface {
    GetAll() ([]models.User, error)
    GetByID(id int) (models.User, error)
    Save(user models.User) error
    Delete(id int) error
}

3. Implement the Repository:

For this example, let's assume we're using a simple in-memory store.

// repository/memory/user_repository_impl.go
package memory

import (
    "your_package_path/models"
    "your_package_path/repository"
)

type UserRepositoryMemory struct {
    users []models.User
}

func NewUserRepositoryMemory() repository.UserRepository {
    return &UserRepositoryMemory{
        users: []models.User{},
    }
}

func (r *UserRepositoryMemory) GetAll() ([]models.User, error) {
    return r.users, nil
}

func (r *UserRepositoryMemory) GetByID(id int) (models.User, error) {
    for _, user := range r.users {
        if user.ID == id {
            return user, nil
        }
    }
    return models.User{}, errors.New("User not found")
}

func (r *UserRepositoryMemory) Save(user models.User) error {
    r.users = append(r.users, user)
    return nil
}

func (r *UserRepositoryMemory) Delete(id int) error {
    for index, user := range r.users {
        if user.ID == id {
            r.users = append(r.users[:index], r.users[index+1:]...)
            return nil
        }
    }
    return errors.New("User not found")
}

4. Use the Repository in your services or application logic:

package main

import (
    "your_package_path/models"
    "your_package_path/repository"
    "your_package_path/repository/memory"
)

func main() {
    // Using the in-memory implementation
    repo := memory.NewUserRepositoryMemory()

    user := models.User{
        ID:   1,
        Name: "John Doe",
    }

    repo.Save(user)

    users, _ := repo.GetAll()
    for _, user := range users {
        fmt.Println(user.Name)
    }
}

With this pattern in place, you can easily swap out your in-memory implementation for, say, a PostgreSQL or a MongoDB implementation without changing your main application logic.

Strategy Pattern in Golang

Tirumal Rao — Fri, 08 Sep 2023 10:52:15 +0000

The Strategy Pattern is a design pattern that allows selecting an implementation of an algorithm's interface at runtime. It allows clients to choose from various implementations of a particular algorithm without altering the code that uses the algorithm.

Example 1

package main

import (
    "fmt"
    "strings"
)

type TranformFunc func(s string) string

func UpperCase(s string) string {
    return strings.ToUpper(s)
}

func Prefixer(prefix string) TranformFunc {
    return func(s string) string {
        return prefix + s
    }
}

func transformString(s string, fn TranformFunc) string {
    return fn(s)
}

func main() {
    fmt.Println(transformString("hello sailor", Prefixer("FOO_")))
}

Here's a breakdown of the code:

1. Strategy Interface:

TranformFunc is the function type that represents the strategy interface.

2. Concrete Strategies:

UpperCase: A strategy that converts a string to uppercase.
Prefixer: Returns another strategy that prefixes a string.

3. Context:

transformString: A function that represents the context. It accepts a string and a strategy and returns the string after applying the strategy.

4. Usage in main function:

In the main() function, we are using the Prefixer strategy to prefix "FOO_" to the string "hello sailor".

Let's see another example to understand the Strategy Pattern even better:

Example 2: Sorting Strategies
Suppose we want to sort a slice of integers, but we want to provide multiple sorting strategies.

package main

import (
    "fmt"
    "sort"
)

type SortStrategy func([]int) []int

func AscendingSort(nums []int) []int {
    sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] })
    return nums
}

func DescendingSort(nums []int) []int {
    sort.Slice(nums, func(i, j int) bool { return nums[i] > nums[j] })
    return nums
}

func sortNumbers(nums []int, strategy SortStrategy) []int {
    return strategy(nums)
}

func main() {
    numbers := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}

    fmt.Println("Original: ", numbers)
    fmt.Println("Ascending Sort:", sortNumbers(numbers, AscendingSort))
    fmt.Println("Descending Sort:", sortNumbers(numbers, DescendingSort))
}

Here:

1. Strategy Interface:

SortStrategy is our strategy interface, which is a function type.

2. Concrete Strategies:

AscendingSort: Sorts a slice of integers in ascending order.
DescendingSort: Sorts a slice of integers in descending order.

3. Context:

sortNumbers: It accepts a slice of integers and a sorting strategy and returns the sorted slice. In the main() function, we have used both strategies to demonstrate the sorting in ascending and descending order.

Credits

First example taken from chapter Advanced interfaces and typed functions in fulltimegodev course by Anthony De Meulemeester

Error handling in Golang

Tirumal Rao — Fri, 08 Sep 2023 02:11:23 +0000

Error handling in Go is somewhat unique compared to some other programming languages. Instead of using exceptions, Go uses error values to indicate an abnormal state. This design promotes explicit error checking and can lead to more robust code.

1. The `error` Type:

Go has a built-in interface type called error. This interface has a single method Error() string.

type error interface {
    Error() string
}

Any type that implements this method can be used as an error.

2. Returning Errors:

It's idiomatic in Go to return errors from functions and methods. A common pattern is to return both a result and an error, and to check the error immediately:

func SomeFunction() (ResultType, error) {
    if somethingWrong {
        return nil, errors.New("something went wrong")
    }
    return result, nil
}

result, err := SomeFunction()
if err != nil {
    // handle the error
}

3. Custom Error Types:

Custom error types can be particularly useful when you want to provide more information about an error or categorize errors in a way that allows the caller to programmatically react to different error scenarios.

Here's an example of how you might use custom error types in Go:

package main

import (
    "fmt"
)

// NotFoundError represents an error when something is not found.
type NotFoundError struct {
    EntityName string
}

func (e *NotFoundError) Error() string {
    return fmt.Sprintf("%s not found", e.EntityName)
}

// PermissionError represents an error when permissions are denied.
type PermissionError struct {
    OperationName string
}

func (e *PermissionError) Error() string {
    return fmt.Sprintf("permission denied for %s", e.OperationName)
}

Using and Checking Custom Error Types:

func FindEntity(name string) (string, error) {
    // Simulating some logic
    if name == "missingEntity" {
        return "", &NotFoundError{EntityName: name}
    }
    return "EntityData", nil
}

func PerformOperation(name string) error {
    // Simulating some logic
    if name == "restrictedOperation" {
        return &PermissionError{OperationName: name}
    }
    return nil
}

func main() {
    _, err := FindEntity("missingEntity")
    if err != nil {
        switch e := err.(type) {
        case *NotFoundError:
            fmt.Println("Handle not found:", e.Error())
        case *PermissionError:
            fmt.Println("Handle permission error:", e.Error())
        default:
            fmt.Println("Handle general error:", e.Error())
        }
    }

    err = PerformOperation("restrictedOperation")
    if err != nil {
        switch e := err.(type) {
        case *NotFoundError:
            fmt.Println("Handle not found:", e.Error())
        case *PermissionError:
            fmt.Println("Handle permission error:", e.Error())
        default:
            fmt.Println("Handle general error:", e.Error())
        }
    }
}

In this example, we have two custom error types: NotFoundError and PermissionError. When we encounter these errors in our functions (FindEntity and PerformOperation), we return instances of these types. In our main function, we can use a type switch to handle different types of errors in different ways.

This approach provides flexibility and clarity in error handling, and allows callers to react differently based on the type of error encountered.

4. The `fmt` Package for Errors:

The fmt package can be used to format error strings. The Errorf function is particularly handy for this:

return fmt.Errorf("error occurred while processing %s", itemName)

5. Wrapping Errors:

As of Go 1.13, the standard library added support for wrapping errors using the %w verb with fmt.Errorf. This allows you to wrap an error with additional context, while preserving the original error:

if err != nil {
    return fmt.Errorf("failed processing: %w", err)
}

You can then later unwrap and check the underlying error using errors.Is and errors.As.

6. Checking Errors:

The errors package provides utilities to work with errors.

errors.Is: Check if an error is a specific error or wrapped version of it.
errors.As: Check if an error matches a certain type and, if so, get the typed value.

var specificErr MyError
if errors.As(err, &specificErr) {
    // handle specificErr
}

Best Practices:

Always handle errors explicitly. Don't ignore them unless you're certain it's safe to do so.
When wrapping errors, provide context so that the root cause can be traced.
Avoid having too many error return values. If a function returns multiple errors, consider if there's a way to simplify or break up the function.
Use custom error types judiciously. Often, a simple error string is sufficient.

By following these practices and understanding Go's unique approach to error handling, you can write more resilient and maintainable code.

How to "go get" from private repository

Tirumal Rao — Thu, 23 Jun 2022 07:18:46 +0000

Installing a go package is breeze with the introduction of go mod. However, when it comes to getting (installing) packages from private repository then it's not that straight forward.

In this post, I'll discuss how to go get from a private repository. I'll show how to get packages from Github.com, but method is almost same for other repository hosting services.

OPERATING SYSTEM: Mac or Linux

STEP 1: Create SSH Key

In this step I'll generate SSH key, in my case I've multiple Github Accounts. One for is personal and another one for my organization I'm currently working with.

Please make sure that you give it a unique file name when asked.

ssh-keygen

Enter a name and select the default location ~/.ssh

Enter file in which to save the key (/Users/<username>/.ssh/id_rsa):

STEP 2: SSH Config file

This step is optional. I'm creating a config file to use multiple SSH keys for multiple GitHub/Bitbucket/Gitlab accounts.

CREATE(if not exist) a file config in ~/.ssh and enter Host configuration for particular SSH keys and Github account.

Here is a sample:

# Bitbucket Account
Host acme
    HostName bitbucket.org
    User git
    IdentityFile ~/.ssh/acme
    IdentitiesOnly yes

# Bitbucket Account
Host simpson
    HostName bitbucket.org
    User git
    IdentityFile ~/.ssh/simpson
    IdentitiesOnly yes

# GitHub Account
Host donald
    HostName github.com
    User git
    IdentityFile ~/.ssh/donald
    IdentitiesOnly yes

STEP 3: Create a Global Git Config

On you terminal enter following command and execute

git config --global url.git@acme:<GITHUB_USER_NAME>.insteadOf https://github.com/<GITHUB_USER_NAME>

Here, acme is the Host configuration from ~/.ssh/config file.

Replace, with your Github username.

If done correctly, the file at location ~/.gitconfig will be modified. The above configuration will added to the EOF.

STEP 4: Now `go get` 😊

go get github.com/<GITHUB_USER_NAME>/private-repo

DEV Community: Tirumal Rao

Configuring kubectl for Minikube Access

Step 1: Set the Cluster

Step 2: Set the Credentials

Step 3: Set the Context

Conclusion

How to Troubleshoot Connectivity Issues with Minikube on Docker

Understanding the Network Setup

Common Network Configurations:

Initial Troubleshooting Steps

Advanced Troubleshooting and Solutions

Configure Routing

Steps to Enable IP Forwarding on Ubuntu:

Adding Static Routes on Mac:

Verify the Route:

To delete the route

Adjust Docker Network Configuration

Using VPN or Tunnels

Conclusion

Golang Interview Questions (Problem Solving)

1. Find the Maximum of Two Numbers

2. Factorial of a Number

3. Fibonacci Sequence

4. Check for Prime Number

5. Slice Reverse

6. Find Element in Slice

7. Check Palindrome String

8. Find the Smallest Number in a Slice

9. Count Occurrences of a Character in a String

10. Check If Two Strings Are Anagrams

11. Merge Two Slices

12. Square Root Without Using Math Package

13. Bubble Sort

14. Binary Search

15. Check Power of Two

16. Find Missing Number in 1..n

17. Find Intersection of Two Slices

18. Rotate Slice by K Elements

19. Unique Elements in a Slice

20. Count Vowels and Consonants in a String

21. Stack Using Slices

22. Map Functions on Slice

23. Filter Elements in Slice

24. Swap Two Numbers Without a Temporary Variable

25. Determine If a String Starts With a Given Substring

26. Determine If a String Ends With a Given Substring

27. Remove Duplicates From a Slice

28. Deep Copy a Slice

29. Count Set Bits of an Integer

30. Convert Integer to Binary String

31. Find GCD of Two Numbers

32. Check If a Number Is Even or Odd

33. Sum of All Elements in a Slice

34. Recursive Sum of Digits of a Number

35. Find the Second Largest Number in a Slice

36. Find the Missing Number in a Sequence

37. Rotate a Slice

38. Count Occurrences of a Character in a String

39. Find the Majority Element

40. Flatten a Nested Slice of Integers

41. Find Intersection of Two Slices

42. Find the First Unique Character in a String

43. Implement strStr()

44. Check If All Characters in a String Are Unique

45. Count Number of Words in a String

46. Convert String to Integer (without using the built-in parsing functions)

47. Find Smallest and Largest Number in a Slice

48. Merge Two Sorted Lists

49. Remove Duplicates from Slice

50. Find the Longest Substring Without Repeating Characters

51. Implement Binary Tree (Bonus Question)

Optimizing Prime Checks with Go (Golang)

Key Points:

FAQ: Why Checking only up to square root of n?

Implementing the Repository Pattern in Go (Golang)

1. Define your domain model:

2. Define the Repository interface:

3. Implement the Repository:

4. Use the Repository in your services or application logic:

Strategy Pattern in Golang

FAQ: Why Checking only up to square root of `n`?

1. The `error` Type:

4. The `fmt` Package for Errors:

STEP 4: Now `go get` 😊