Forem: Mohammad Reza

From PHP to Go: Recognizing and Avoiding PHP-ish Patterns in Go Projects (part 2)

Mohammad Reza — Wed, 27 Nov 2024 12:09:43 +0000

Overengineering: Bringing Laravel’s Complexity into Go

Introduction

In the realm of software development, choosing the right tools and frameworks is paramount for building efficient and maintainable applications. Laravel, a popular PHP framework, offers a rich set of features that can accelerate development but also introduces significant complexity. Go (Golang), in contrast, emphasizes simplicity and minimalism, encouraging developers to write clear and straightforward code.

This article explores the pitfalls of overengineering by attempting to transplant Laravel's complexity into Go. We'll focus on three critical areas where this can occur:

Implementing Laravel's Service Container in Go
Mimicking Eloquent ORM in Go
Recreating Laravel's Routing and Middleware

By examining these areas with well-defined examples, we'll understand why embracing Go's idioms leads to better software design and how to handle common development tasks effectively in Go without unnecessary complexity.

1. Implementing Laravel's Service Container in Go

The Pitfall: Overcomplicating Dependency Injection

In Laravel: The service container is a powerful tool that manages class dependencies and performs dependency injection (DI), allowing for flexible and decoupled code.

The Overengineering Trap in Go: Attempting to replicate Laravel's service container leads to unnecessary complexity, making the code harder to understand and maintain.

Overengineered Example in Go:

// Service interface defines the behavior
type Service interface {
    PerformTask()
}

// ConcreteService implements the Service interface
type ConcreteService struct{}

func (s *ConcreteService) PerformTask() {
    fmt.Println("Task performed")
}

// ServiceContainer holds service instances
type ServiceContainer struct {
    services map[string]interface{}
}

func NewServiceContainer() *ServiceContainer {
    return &ServiceContainer{services: make(map[string]interface{})}
}

func (c *ServiceContainer) Register(name string, service interface{}) {
    c.services[name] = service
}

func (c *ServiceContainer) Get(name string) interface{} {
    return c.services[name]
}

func main() {
    container := NewServiceContainer()
    container.Register("service", &ConcreteService{})

    svc := container.Get("service").(Service)
    svc.PerformTask()
}

Issues with This Approach:

Unnecessary Abstraction: Introducing a service container adds complexity without clear benefits in Go.
Type Safety Compromised: Using interface{} requires type assertions, leading to potential runtime errors.
Maintenance Overhead: The code becomes harder to read and maintain.

Embracing Go's Simplicity: Idiomatic Dependency Injection

Go favors explicitness and simplicity. Dependency injection can be achieved without a service container.

Idiomatic Example in Go:

// Service interface remains the same
type Service interface {
    PerformTask()
}

// ConcreteService implements the Service interface
type ConcreteService struct{}

func (s *ConcreteService) PerformTask() {
    fmt.Println("Task performed")
}

// Function that uses the Service interface
func ExecuteTask(svc Service) {
    svc.PerformTask()
}

func main() {
    service := &ConcreteService{}
    ExecuteTask(service)
}

Benefits of This Approach:

Explicit Dependencies: Dependencies are passed directly, making them clear and manageable.
Type Safety Ensured: Interfaces provide compile-time checks.
Simplified Codebase: Easier to read, understand, and maintain.

2. Mimicking Eloquent ORM in Go

The Pitfall: Introducing Heavy ORM Abstractions

In Laravel: Eloquent ORM provides an active record implementation, making database interactions intuitive but heavily abstracted.

The Overengineering Trap in Go: Recreating Eloquent's functionality in Go can lead to complex code that doesn't leverage Go's strengths and may introduce performance issues.

Overengineered Example in Go:

type Model struct {
    tableName string
}

func (m *Model) Find(id int) map[string]interface{} {
    // Complex reflection and query building (hypothetical)
    return map[string]interface{}{}
}

type User struct {
    Model
    ID   int
    Name string
}

func main() {
    user := User{}
    user.tableName = "users"
    data := user.Find(1)
    fmt.Println(data)
}

Issues with This Approach:

Reflection Overuse: Go's reflection is less flexible and can be inefficient compared to PHP.
Loss of Type Safety: Returning map[string]interface{} loses compile-time checks.
Increased Complexity: Obscures the underlying operations, making debugging difficult.

Embracing Go's Database Handling: Using `database/sql` and Lightweight Libraries

Go's standard library provides powerful tools for database interactions without heavy abstractions. By using the database/sql package along with lightweight helper libraries, you can achieve efficient database operations while maintaining simplicity.

Using `database/sql` Effectively

Example with database/sql:

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    ID   int
    Name string
}

func main() {
    // Establish database connection
    db, err := sql.Open("mysql", "user:password@/dbname")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Prepare query
    stmt, err := db.Prepare("SELECT id, name FROM users WHERE id = ?")
    if err != nil {
        log.Fatal(err)
    }
    defer stmt.Close()

    // Execute query
    user := User{}
    err = stmt.QueryRow(1).Scan(&user.ID, &user.Name)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("User: %+v\n", user)
}

Benefits of This Approach:

Type Safety: Struct fields ensure data types are correct.
Performance: Direct queries are efficient and transparent.
Simplicity: Clear and maintainable code that leverages Go's strengths.

Using Helper Libraries like `sqlx` for Convenience

For developers who desire some convenience without the overhead of a full ORM, sqlx extends database/sql to make working with databases easier.

Example with sqlx:

import (
    "fmt"
    "log"

    "github.com/jmoiron/sqlx"
    _ "github.com/go-sql-driver/mysql"
)

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

func main() {
    // Connect to the database
    db, err := sqlx.Connect("mysql", "user:password@/dbname")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Fetch a user
    user := User{}
    err = db.Get(&user, "SELECT id, name FROM users WHERE id = ?", 1)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("User: %+v\n", user)
}

Benefits:

Convenience Methods: sqlx provides Get, Select, and named query support.
Minimal Abstraction: Enhances database/sql without hiding the underlying SQL.
Type Safety and Struct Scanning: Maps query results directly into structs.

Considering ORM Libraries Like GORM

If you require more abstraction and features like automatic migrations, associations, and more, Go has ORM libraries like GORM. However, it's important to weigh the benefits against the added complexity and potential performance implications.

Example with GORM:

import (
    "fmt"
    "log"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

type User struct {
    ID   int
    Name string
}

func main() {
    // Setup GORM with MySQL
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal(err)
    }

    // Query using GORM
    var user User
    result := db.First(&user, 1)
    if result.Error != nil {
        log.Fatal(result.Error)
    }

    fmt.Printf("User: %+v\n", user)
}

Considerations When Using GORM:

Abstraction Level: GORM provides higher-level abstractions, which can be beneficial but may hide the underlying SQL operations.
Performance: ORMs can introduce overhead; profiling is essential to ensure performance meets requirements.
Complexity vs. Convenience: Evaluate whether the features provided justify the added complexity.

Making an Informed Choice

When handling database interactions in Go, it's crucial to:

Understand Your Needs: Determine whether you need the features provided by an ORM or if direct SQL queries suffice.
Balance Abstraction and Control: Choose a tool that offers the right balance for your project's complexity and performance requirements.
Leverage Go's Strengths: Utilize Go's type safety and concurrency features to build robust database interactions.

3. Recreating Laravel's Routing and Middleware

The Pitfall: Overcomplicating HTTP Handling

In Laravel: Routing and middleware are handled through a sophisticated system that provides flexibility but adds layers of abstraction.

The Overengineering Trap in Go: Rebuilding this system in Go can result in unnecessary complexity and reduced performance.

Overengineered Example in Go:

type Middleware func(http.HandlerFunc) http.HandlerFunc

type Router struct {
    routes     map[string]http.HandlerFunc
    middleware []Middleware
}

func NewRouter() *Router {
    return &Router{
        routes:     make(map[string]http.HandlerFunc),
        middleware: []Middleware{},
    }
}

func (r *Router) Use(mw Middleware) {
    r.middleware = append(r.middleware, mw)
}

func (r *Router) AddRoute(path string, handler http.HandlerFunc) {
    // Apply middleware in reverse order
    for i := len(r.middleware) - 1; i >= 0; i-- {
        handler = r.middleware[i](handler)
    }
    r.routes[path] = handler
}

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    if handler, ok := r.routes[req.URL.Path]; ok {
        handler(w, req)
    } else {
        http.NotFound(w, req)
    }
}

func main() {
    router := NewRouter()
    router.Use(loggingMiddleware)
    router.AddRoute("/", homeHandler)

    http.ListenAndServe(":8080", router)
}

Issues with This Approach:

Redundant Effort: Go's net/http package already provides routing and middleware capabilities.
Increased Complexity: Custom implementations can introduce bugs and maintenance challenges.

Embracing Go's `net/http`: Simple and Effective

Go's standard library enables building HTTP servers efficiently without extra layers.

Idiomatic Example with net/http:

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

// Middleware function
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    })
}

// Handler function
func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Welcome to the Home Page!")
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", homeHandler)

    // Wrap the mux with middleware
    handler := loggingMiddleware(mux)

    log.Println("Server starting on :8080")
    err := http.ListenAndServe(":8080", handler)
    if err != nil {
        log.Fatal(err)
    }
}

Benefits of This Approach:

Simplicity: Uses built-in functionalities without reinventing the wheel.
Flexibility: Middleware can be easily added or removed.
Performance: Minimal overhead ensures efficient handling of requests.

Utilizing Third-Party Routers When Needed

For more complex routing requirements, Go has third-party routers like gorilla/mux or httprouter.

Example with gorilla/mux:

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/mux"
)

func userHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userID := vars["id"]
    fmt.Fprintf(w, "User ID: %s\n", userID)
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/users/{id}", userHandler)

    log.Println("Server starting on :8080")
    err := http.ListenAndServe(":8080", r)
    if err != nil {
        log.Fatal(err)
    }
}

Benefits:

Named Parameters: Support for dynamic routes.
Middleware Support: Easier to apply middleware to specific routes.
Community Support: Widely used and maintained.

Considerations:

Evaluate Complexity: Ensure that adding a third-party router is justified by your application's needs.
Performance Implications: Third-party routers may introduce slight overhead; profile if necessary.

Conclusion

Attempting to bring Laravel's complexity into Go often results in overengineered solutions that conflict with Go's philosophy of simplicity and clarity. By embracing Go's idioms and leveraging its powerful standard library, developers can write code that is:

Efficient: Lean code that performs well.
Maintainable: Easier to read, understand, and extend.
Reliable: Type safety and explicit error handling reduce bugs.

Key Takeaways:

Understand the Language Philosophy: Go is designed for simplicity; align your coding practices accordingly.
Leverage Standard Libraries and Lightweight Tools: Use Go's built-in packages and consider lightweight libraries that complement the language's strengths.
Avoid Unnecessary Abstractions: Only introduce complexity when it provides clear benefits.
Embrace Explicitness: Clear and direct code enhances maintainability and reduces errors.
Make Informed Choices: Evaluate your application's needs to choose the right tools and patterns.

By focusing on these principles, you can avoid the pitfalls of overengineering and fully harness the power of Go to build robust, scalable applications.

Additional Resources

Go Official Documentation: https://golang.org/doc/
Effective Go: https://golang.org/doc/effective_go.html
GORM Documentation: https://gorm.io/docs/
sqlx Documentation: https://jmoiron.github.io/sqlx/
Go by Example: https://gobyexample.com/
Gorilla Mux Documentation: https://www.gorillatoolkit.org/pkg/mux

By understanding the contrasts between Laravel and Go, and by embracing Go's native strengths, developers can write better code and avoid the trap of overengineering. Remember, simplicity is not about doing less; it's about doing more with less complexity.

From PHP to Go: Recognizing and Avoiding PHP-ish Patterns in Go Projects (part 1)

Mohammad Reza — Wed, 27 Nov 2024 11:37:09 +0000

Introduction

As developers, we carry mental models and habits from one language to another. While this cross-pollination of ideas can sometimes enhance our work, it often leads to subtle misalignments when adopting a new language—especially when transitioning from a highly dynamic and flexible language like PHP to a statically typed, minimalist language like Go.

You may have heard comments like, "This Go project feels PHP-ish" or "A PHP developer must have written this." These remarks often highlight deeper issues: a mismatch between the principles of Go and the practices brought over from PHP. This isn’t just about code—it’s about the architectural mindset and how projects are structured and organized.

Why Go Prefers Composition Over Inheritance

When designing extensible systems, one of the most common dilemmas is deciding between inheritance and composition. Inheritance, while familiar to many developers, can lead to rigid hierarchies and exponential complexity as new behaviors are added. Go’s philosophy favors composition, enabling flexibility, modularity, and scalability.

In this article, we’ll explore this comparison through the example of a Task Execution System. We’ll build the system using both inheritance and composition, compare the results, and highlight why Go's composition-first philosophy is often the better choice.

Scenario: A Task Execution System

We want to design a system where:

Basic tasks like EmailTask and DatabaseTask can be executed.
Additional behaviors like notifications and retries can be added to tasks.
The system should be extensible for future behaviors (e.g., logging, metrics).

Inheritance-Based Approach

Using inheritance, we extend tasks by creating new subclasses to add behaviors. While this approach is familiar, it quickly becomes cumbersome as new behaviors and combinations are introduced.

package main

import "fmt"

// Base Task
type Task struct {
    Name string
}

func (t *Task) Execute() {
    fmt.Println("Executing task:", t.Name)
}

// EmailTask inherits from Task
type EmailTask struct {
    Task
}

func (e *EmailTask) Execute() {
    fmt.Println("Sending email task:", e.Name)
}

// DatabaseTask inherits from Task
type DatabaseTask struct {
    Task
}

func (d *DatabaseTask) Execute() {
    fmt.Println("Executing database task:", d.Name)
}

// Add Notification by Extending Task
type NotifyingEmailTask struct {
    EmailTask
}

func (n *NotifyingEmailTask) Execute() {
    fmt.Println("Sending notification before executing email task...")
    n.EmailTask.Execute()
    fmt.Println("Sending notification after executing email task...")
}

type NotifyingDatabaseTask struct {
    DatabaseTask
}

func (n *NotifyingDatabaseTask) Execute() {
    fmt.Println("Sending notification before executing database task...")
    n.DatabaseTask.Execute()
    fmt.Println("Sending notification after executing database task...")
}

// Add Retry Behavior by Extending Task
type RetryingNotifyingEmailTask struct {
    NotifyingEmailTask
    Retry int
}

func (r *RetryingNotifyingEmailTask) Execute() {
    for i := 0; i < r.Retry; i++ {
        fmt.Printf("Retry %d: ", i+1)
        r.NotifyingEmailTask.Execute()
    }
}

type RetryingNotifyingDatabaseTask struct {
    NotifyingDatabaseTask
    Retry int
}

func (r *RetryingNotifyingDatabaseTask) Execute() {
    for i := 0; i < r.Retry; i++ {
        fmt.Printf("Retry %d: ", i+1)
        r.NotifyingDatabaseTask.Execute()
    }
}

func main() {
    fmt.Println("Executing notifying tasks:")
    notifyingEmailTask := NotifyingEmailTask{EmailTask{Task{Name: "Weekly Newsletter"}}}
    notifyingDbTask := NotifyingDatabaseTask{DatabaseTask{Task{Name: "DB Backup"}}}

    notifyingEmailTask.Execute()
    notifyingDbTask.Execute()

    fmt.Println("\nExecuting retrying notifying tasks:")
    retryingNotifyingEmailTask := RetryingNotifyingEmailTask{
        NotifyingEmailTask: NotifyingEmailTask{EmailTask{Task{Name: "Weekly Newsletter"}}},
        Retry:              3,
    }

    retryingNotifyingDbTask := RetryingNotifyingDatabaseTask{
        NotifyingDatabaseTask: NotifyingDatabaseTask{DatabaseTask{Task{Name: "DB Backup"}}},
        Retry:                 2,
    }

    retryingNotifyingEmailTask.Execute()
    retryingNotifyingDbTask.Execute()
}

Problems with the Inheritance Approach

Behavior Explosion: Adding behaviors like retries or notifications requires creating a new subclass for each combination. Example: RetryingNotifyingEmailTask and RetryingNotifyingDatabaseTask.
Tight Coupling: Behaviors are tightly bound to specific task types (EmailTask, DatabaseTask).
Limited Extensibility:Adding new behaviors (e.g., logging) requires modifying existing classes or creating additional subclasses.

Composition-Based Approach

Using composition, we build the same system by combining smaller, reusable components (decorators). This approach avoids the pitfalls of inheritance.

package main

import "fmt"

// Task interface defines the behavior
type Task interface {
    Execute()
}

// Basic tasks implement the Task interface
type EmailTask struct {
    Name string
}

func (e EmailTask) Execute() {
    fmt.Println("Sending email task:", e.Name)
}

type DatabaseTask struct {
    Name string
}

func (d DatabaseTask) Execute() {
    fmt.Println("Executing database task:", d.Name)
}

// Notifier decorator adds notification behavior
type Notifier struct {
    Task Task
}

func (n Notifier) Execute() {
    fmt.Println("Sending notification before task execution...")
    n.Task.Execute()
    fmt.Println("Sending notification after task execution...")
}

// Retry decorator adds retry behavior
type Retry struct {
    Task  Task
    Retry int
}

func (r Retry) Execute() {
    for i := 0; i < r.Retry; i++ {
        fmt.Printf("Retry %d: ", i+1)
        r.Task.Execute()
    }
}

func main() {
    fmt.Println("Executing notifying tasks:")
    Notifier{Task: EmailTask{Name: "Weekly Newsletter"}}.Execute()
    Notifier{Task: DatabaseTask{Name: "DB Backup"}}.Execute()

    fmt.Println("\nExecuting retrying notifying tasks:")
    Retry{
        Task: Notifier{
            Task: EmailTask{Name: "Weekly Newsletter"},
        },
        Retry: 3,
    }.Execute()

    Retry{
        Task: Notifier{
            Task: DatabaseTask{Name: "DB Backup"},
        },
        Retry: 2,
    }.Execute()
}

The inheritance approach becomes rigid and unmanageable as the number of behaviors grows, while the composition approach:

Keeps code modular and reusable.
Supports dynamic behavior combination.
Simplifies adding new features.

Zero Down Time Deployment!

Mohammad Reza — Mon, 31 Oct 2022 04:24:47 +0000

First Step

let's consider we have one nginx and one php node and we want to deploy on php node without down time
Our structure is like this

.
├── app
│   └── index.php
├── docker-compose.yml
├── nginx.Dockerfile
├── nginx.conf
└── php.Dockerfile

That is our docker-compose.yml

version: "3.7"

services:
    cicd-nginx:
        build:
          context: .
          dockerfile: nginx.Dockerfile
        ports:
            - "88:80"
        volumes:
            - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro

    cicd-php:
        build:
          context: .
          dockerfile: php.Dockerfile

That is our nginx.Dockerfile

FROM nginx:1.17-alpine

WORKDIR /app
COPY ./app ./

That is our nginx.conf

server {
    listen 80;
    index index.php index.html;

    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;

    root /app;
    server_name localhost;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass cicd-php:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;

    }
}

That is our simple php.Dockerfile

FROM php:8.1-fpm-alpine

WORKDIR /app
COPY ./app ./

And at the end that is our simple index.php

<?php

echo "hi"

?>

Let's go to the next interesting part

First we change build with image because we want to first build the image and then just replace the new one with the old one, so our docker-compose.yml will become like this:

version: "3.7"

services:
    cicd-nginx:
        image: ${NGINX_IMAGE_TAG}
        ports:
            - "88:80"
        volumes:
            - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro

    cicd-php:
        image: ${PHP_IMAGE_TAG}

First set the variables and the need to build the images

export PHP_IMAGE_TAG=phptest:1
export NGINX_IMAGE_TAG=nginxtest:1

docker build -f php.Dockerfile -t $PHP_IMAGE_TAG .
docker build -f nginx.Dockerfile -t $NGINX_IMAGE_TAG .

Then we just run up -d

Now I want to show you what will happen if you just want to deploy the new code

First we prepare a bash script for it (./script.sh):

#!/bin/bash
while :
do
    echo "Your response : "
    curl 127.0.0.1:88
    echo " "
    date
    sleep 2
done

Now we just change the php file to sth like

<?php

echo "hi hi :)"

?>

And then we try to build it with new name

export PHP_IMAGE_TAG=phptest:2
docker build -f php.Dockerfile -t $PHP_IMAGE_TAG .

Now we want run the script and then run these commands to update the php container

sh ./script.sh

And

docker-compose down
docker-compose up -d

Result

You will see sth like this and that is the problem

...
Your response : 
hi 
Mon Oct 31 00:31:23 UTC 2022
Your response : 
hi 
Mon Oct 31 00:31:25 UTC 2022
Your response : 
hi 
Mon Oct 31 00:31:27 UTC 2022
Your response : 
hi 
Mon Oct 31 00:31:30 UTC 2022
Your response : 
curl: (7) Failed to connect to localhost port 88: Connection refused

Mon Oct 31 00:31:32 UTC 2022
Your response : 
curl: (7) Failed to connect to localhost port 88: Connection refused

Mon Oct 31 00:31:34 UTC 2022
Your response : 
curl: (7) Failed to connect to localhost port 88: Connection refused

Mon Oct 31 00:31:36 UTC 2022
Your response : 
curl: (7) Failed to connect to localhost port 88: Connection refused

Mon Oct 31 00:31:38 UTC 2022
Your response : 
<html>
<head><title>502 Bad Gateway</title></head>
<body>
<center><h1>502 Bad Gateway</h1></center>
<hr><center>nginx/1.17.10</center>
</body>
</html>

Mon Oct 31 00:31:40 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:31:42 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:31:44 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:31:46 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:31:48 UTC 2022
...

You can feel what is the problem right now so let's try to fix it

We want to use docker swarm

First init it

docker swarm init

Then update your docker-compose.yml like this:

version: "3.7"

services:
    cicd-nginx:
        image: ${NGINX_IMAGE_TAG}
        ports:
            - "88:80"
        volumes:
            - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
        deploy:
          mode: replicated
          replicas: 2
          update_config:
            order: start-first
            failure_action: rollback
            delay: 5s

    cicd-php:
        image: ${PHP_IMAGE_TAG}
        deploy:
          mode: replicated
          replicas: 2
          update_config:
            order: start-first
            failure_action: rollback
            delay: 5s

Then run this command and now you are up

docker stack deploy -c docker-compose.yml <stack_name>

Let's look at containers

CONTAINER ID   IMAGE                   COMMAND                  CREATED              STATUS              PORTS                                       NAMES
6cc2b3516a3a   phptest:2               "docker-php-entrypoi…"   About a minute ago   Up About a minute   9000/tcp                                    website_cicd-php.1.ijd0lpj995318hpffx6gx5t44
7cffa4115598   phptest:2               "docker-php-entrypoi…"   About a minute ago   Up About a minute   9000/tcp                                    website_cicd-php.2.jbd2sg2qm6ounji76q99fk2ql
fcedfb42b44a   nginxtest:1             "nginx -g 'daemon of…"   About a minute ago   Up About a minute   80/tcp                                      website_cicd-nginx.2.8z4spuco9rtdxcpc8y0fux79p
99e1642cf461   nginxtest:1             "nginx -g 'daemon of…"   About a minute ago   Up About a minute   80/tcp                                      website_cicd-nginx.1.eo6erxose7asze8ref2poracc

We have 2 php node and 2 nginx node :)
Let's update the php node and see the result
Change the php file and add one hi

<?php

echo "hi hi hi :)"

?>

And then we try to build php node it with new name

export PHP_IMAGE_TAG=phptest:3
docker build -f php.Dockerfile -t $PHP_IMAGE_TAG .

Now we want run the script and then run the command to update the php container

sh ./script.sh

And

docker stack deploy -c docker-compose.yml <stack_name>

Result

...
Your response : 
hi hi :) 
Mon Oct 31 00:53:53 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:53:55 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:53:57 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:53:59 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:54:01 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:03 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:54:05 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:07 UTC 2022
Your response : 
hi hi :) 
Mon Oct 31 00:54:09 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:11 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:13 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:15 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:17 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:19 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:21 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:23 UTC 2022
Your response : 
hi hi hi:) 
Mon Oct 31 00:54:25 UTC 2022
...

Wow And that is the magic
We do not have any down time and docker swarm completely handle it for us

let's make .gitlab-ci.yml for it

Step one

Create a project in gitlab

Step two

Add project to the git and then push it

git init
git add .
git commit -m "init"
git remote add origin git@gitlab.com:azibom/cicd.git

Step three

Add .gitlab-ci.yml to the project

image: docker:20.10.16

stages:
  - publish
  - deploy

variables:
  PHP_IMAGE_TAG: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:php-$CI_COMMIT_SHORT_SHA
  NGINX_IMAGE_TAG: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:nginx-$CI_COMMIT_SHORT_SHA
  DOCKER_TLS_CERTDIR: "/certs"

services:
  - docker:20.10.16-dind

before_script:
  - 'command -v ssh-agent >/dev/null || ( apk add --update openssh )' 
  - eval $(ssh-agent -s)
  - echo "${SSH_PRIVATE_KEY}" | tr -d '\r' | ssh-add -
  - mkdir -p ~/.ssh
  - chmod 700 ~/.ssh

publish:
  stage: publish
  script:
    - docker build -f php.Dockerfile -t $PHP_IMAGE_TAG .
    - docker build -f nginx.Dockerfile -t $NGINX_IMAGE_TAG .
    - docker login -u gitlab-ci-token -p $CI_BUILD_TOKEN $CI_REGISTRY
    - docker push $PHP_IMAGE_TAG
    - docker push $NGINX_IMAGE_TAG

deploy:
  image: alpine:latest
  stage: deploy
  script:
    - ssh -o StrictHostKeyChecking=no $SERVER_USER@$SERVER_IP "cd $PROJECT_DIR && docker login -u gitlab-ci-token -p $CI_BUILD_TOKEN $CI_REGISTRY && docker pull $NGINX_IMAGE_TAG && docker pull $PHP_IMAGE_TAG && export PHP_IMAGE_TAG=$PHP_IMAGE_TAG && export NGINX_IMAGE_TAG=$NGINX_IMAGE_TAG && docker stack deploy --with-registry-auth -c docker-compose.yml website"
  only:
    - master

Step Four

Add some variables to the gitlab ci from setting

PROJECT_DIR && SERVER_IP && SERVER_USER && SSH_PRIVATE_KEY

You can find SSH_PRIVATE_KEY with run this command

cat ~/.ssh/id_rsa

Also run this on server

cat ~/.ssh/id_rsa.pub > ~/.ssh/authorized_keys

Step five

Define your own runner

curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh > script.deb.sh
sudo bash script.deb.sh
sudo apt install gitlab-runner
systemctl status gitlab-runner
sudo gitlab-runner register -n \
  --url https://gitlab.com/ \
  --registration-token REGISTRATION_TOKEN \
  --executor docker \
  --description "My Docker Runner" \
  --docker-image "docker:20.10.16" \
  --docker-privileged \
  --docker-volumes "/certs/client"

(bring REGISTRATION_TOKEN from gitlab.com)

Step six

Push to your server and look at pipline

Step seven , Done

Best wishes

How To Set Up an OpenVPN Server on Linux Server (Ubuntu)

Mohammad Reza — Mon, 19 Sep 2022 14:54:04 +0000

You can easily follow this steps to have your own VPN on your server.

1 . Install docker in your server

sudo apt install docker.io

2 . Make a directory with this command

mkdir /opt/openvpn
cd /opt/openvpn

3 . Pick a name for the $OVPN_DATA data volume container

OVPN_DATA="ovpn-data"

4 . Initialize the $OVPN_DATA container that will hold the configuration files and certificates. (replace VPN.SERVERNAME.COM with your server IP)

docker volume create --name $OVPN_DATA
docker run -v $OVPN_DATA:/etc/openvpn --rm kylemanna/openvpn ovpn_genconfig -u udp://VPN.SERVERNAME.COM
docker run -v $OVPN_DATA:/etc/openvpn --rm -it kylemanna/openvpn ovpn_initpki

5 . Start OpenVPN server process

docker run -v $OVPN_DATA:/etc/openvpn -d -p 1194:1194/udp --cap-add=NET_ADMIN kylemanna/openvpn

6 . Take a rest, drink water, walk :))

7 . Generate a client certificate without a passphrase (replace CLIENTNAME with what you want!)

docker run -v $OVPN_DATA:/etc/openvpn --rm -it kylemanna/openvpn easyrsa build-client-full CLIENTNAME nopass

8 . Retrieve the client configuration with embedded certificates

docker run -v $OVPN_DATA:/etc/openvpn --rm kylemanna/openvpn ovpn_getclient CLIENTNAME > CLIENTNAME.ovpn

You can also use a trick for making ovpn
Make a bash file, name it script.sh and wirte these in it

OVPN_DATA="ovpn-data"
docker run -v $OVPN_DATA:/etc/openvpn --rm -it kylemanna/openvpn easyrsa build-client-full $CLIENTNAME nopass
docker run -v $OVPN_DATA:/etc/openvpn --rm kylemanna/openvpn ovpn_getclient $CLIENTNAME > $CLIENTNAME.ovpn

Now if you want to make ovpn for 10 people you can run this command

for i in {1..10}; do export CLIENTNAME=user$i && sh script.sh ; done

9 . Now you can find your .ovpn file in /opt/openvpn

10 . (Optional) Just copy files to your machine ,go to your local machine and run this command

scp root@<your-server-ip>:/opt/openvpn/*.ovpn /home/azibom

If you have any questions, you can ask here:)
Share with your friends if you like

Login to the server without password

Mohammad Reza — Mon, 04 Apr 2022 10:03:19 +0000

That is a very nice way if you want to dont write your password for every login to the server :)

cd ~/.ssh
ls

If you have "id_rsa.pub" you dont need to generate it but if you dont have it lets make it

ssh-keygen -o -t rsa -C "azibom@gmail.com"

Now you should see it in ~/.ssh
Lets copy it

cat ~/.ssh/id_rsa.pub

Then you need to login to the server and add this key to the remote server
Run this command

nano .ssh/authorized_keys

And paste what you copied at the end of this file
And now you have login to the server without password :)

ci/cd with gitlab (part one)

Mohammad Reza — Tue, 28 Dec 2021 13:26:43 +0000

In this article we try to just run a command from the pipline in our server

Make sure you can connect to your server via your ssh-key without requiring password.
On gitlab, go to your repository > settings > CI/CD > Variables
Add a new variable SSH_PRIVATE_KEY. The value is your ssh private key (e.g content of ~/.ssh/id_rsa)
Add the file below to your project

.gitlab-ci.yml

before_script:
  - apt-get update -qq
  - apt-get install -qq git
  - "which ssh-agent || ( apt-get install -qq openssh-client )"
  - eval $(ssh-agent -s)
  - ssh-add <(echo "$SSH_PRIVATE_KEY")
  - mkdir -p ~/.ssh
  - '[[ -f /.dockerenv ]] && echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config'

deploy:
  type: deploy
  script:
    - ssh root@123.123.123.123 "pwd && ls"
  only:
    - main

After that you need to run this command because You need to add the public key to the server so it would be recognized as an authentication key.

cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

Just consider to change root@123.123.123.123 the use and also the IP address.
Now if you push to the main branch it will run the pipeline and then run the command on your server :))
In the next article we use this to deploy our project to the server automatically

That is all

XDebug, VScode, ubuntu

Mohammad Reza — Sun, 28 Mar 2021 07:14:22 +0000

For installing the XDebug in ubuntu and use it from VScode follow these steps

1.Step one

Run this command

sudo apt install php-xdebug

2.Step two

Run this command

sudo nano /etc/php/7.4/mods-available/xdebug.ini

Then go to the end of the file and add these lines

[xdebug]
zend_extension=/usr/lib/php/20190902/xdebug.so
xdebug.mode = debug
xdebug.start_with_request = yes
xdebug.client_port = 9000

For finding the path of the xdebug (/usr/lib/php/20190902/xdebug.so)
you can run this command

locate xdebug.so

3.Step three

Open the configuration file of Xdebug by clicking ‘Add Configuration…’ from the menu Run and set the necessary configuration according to the xdebug.ini file.
It will become sth like this

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Listen for XDebug",
            "type": "php",
            "request": "launch",
            "port": 9000,
        },
        {
            "name": "Launch currently open script",
            "type": "php",
            "request": "launch",
            "program": "${file}",
            "cwd": "${fileDirname}",
            "port": 9000
        }
    ]
}

Done

Run docker commands without sudo :))

Mohammad Reza — Fri, 10 Jul 2020 10:41:37 +0000

First create a docker group

sudo groupadd docker

Add the connected user $USER to the docker group

sudo gpasswd -a $USER docker

Done

Log out and log back in so that your group membership is re-evaluated.

If testing on a virtual machine, it may be necessary to restart the virtual machine for changes to take effect.

On a desktop Linux environment such as X Windows, log out of your session completely and then log back in.

On Linux, you can also run the following command to activate the changes to groups:

 newgrp docker

Change php version

Mohammad Reza — Sun, 28 Jun 2020 16:34:39 +0000

Just write "update-alternatives --config php" :)

SSH Keys for GitHub (Debian GNU/Linux)

Mohammad Reza — Tue, 23 Jun 2020 11:38:42 +0000

That is a very nice way if you want to dont write your password for every push in Github :)

cd ~/.ssh
ls

If you have "id_rsa.pub" you dont need to generate it but if you dont have it lets make it

 ssh-keygen -o -t rsa -C "azibom@gmail.com"

Now you should see it in ~/.ssh
Lets open it

cat cat ~/.ssh/id_rsa.pub

Now copy what you see and go to your github

Go to Account Settings > Ssh keys and pase what you have been copied

And now save it
Done

Define your own facade in laravel

Mohammad Reza — Wed, 17 Jun 2020 13:41:14 +0000

In this article we want to know how can we define our own facade
and use it in our application

In this article I want to make SmartLogger class and try to use it with Facades so lets start

Create a directory in app and which has SmartLogger name and fill it like below

.
├── SmartLoggerFacade.php
└── SmartLogger.php

0 directories, 2 files

SmartLogger.php

<?php

namespace App\SmartLogger;

class SmartLogger {
    public function log($text) {
        $path = storage_path('logs');
        $myfile = fopen("{$path}/SmartLog.txt", "a");
        fwrite($myfile, $text);
        fwrite($myfile, PHP_EOL);
        fclose($myfile);
    }
}

SmartLoggerFacade.php

<?php

namespace App\SmartLogger;
use Illuminate\Support\Facades\Facade;

class SmartLoggerFacade extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'smartlogger';
    }
}

lets make service provider

php artisan make:provider SmartLoggerServiceProvider

SmartLoggerServiceProvider.php

<?php

namespace App\Providers;

use App\SmartLogger\SmartLogger;
use Illuminate\Support\ServiceProvider;

class SmartLoggerServiceProvider extends ServiceProvider
{
    /**
     * Register services.
     *
     * @return void
     */
    public function register()
    {
        $this->app->bind('smartlogger',function(){
            return new SmartLogger();
        });
    }

    /**
     * Bootstrap services.
     *
     * @return void
     */
    public function boot()
    {
        //
    }
}

Now open config\app.php and add this lines in it

Add it in "providers" array

...
        App\Providers\SmartLoggerServiceProvider::class

Add it in "aliases" array

...
        'Smartlogger'   =>  App\SmartLogger\SmartLoggerFacade::class

Now lets test it :)

Add this code in your controller

SmartLogger::log("Hi");

And add this in top of your controller

use App\SmartLogger\SmartLoggerFacade as SmartLogger;

Feel free to ask any questions :)

Laravel Events

Mohammad Reza — Wed, 17 Jun 2020 08:35:55 +0000

Events provide a simple observer implementation which allows a user to subscribe and listen to various events triggered in the web application. All the event classes in Laravel are stored in the app/Events folder and the listeners are stored in the app/Listeners folder.

Lets start

Run these commands

php artisan event:generate
php artisan make:event UserRegisteredEvent
php artisan make:listener SendMailListener --event="UserRegisteredEvent"

UserRegisteredEvent.php

<?php

namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class UserRegisteredEvent
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public $title;
    public $body;
    public $to;

    public function __construct($title, $body, $to)
    {
        $this->title = $title;
        $this->body = $body;
        $this->to = $to;
    }

    /**
     * Get the channels the event should broadcast on.
     *
     * @return \Illuminate\Broadcasting\Channel|array
     */
    public function broadcastOn()
    {
        return new PrivateChannel('channel-name');
    }
}

<?php

namespace App\Listeners;

use App\Events\UserRegisteredEvent;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;

class SendMailListener implements ShouldQueue
{
    /**
     * Create the event listener.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    /**
     * Handle the event.
     *
     * @param  UserRegisteredEvent  $event
     * @return void
     */
    public function handle(UserRegisteredEvent $event)
    {
        echo "Start sending email".PHP_EOL;
        sleep(2);
        echo "Email sended to {$event->to}".PHP_EOL;
    }
}

EventServiceProvider.php

<?php

namespace App\Providers;

use Illuminate\Auth\Events\Registered;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Event;

class EventServiceProvider extends ServiceProvider
{
    /**
     * The event listener mappings for the application.
     *
     * @var array
     */
    protected $listen = [
        'App\Events\UserRegistered' => [
            'App\Listeners\SendRegistrationEmail',
        ],
    ];

    /**
     * Register any events for your application.
     *
     * @return void
     */
    public function boot()
    {
        parent::boot();

        //
    }
}

Now add somethings like this in your controller for example

        for ($i=0; $i < 10; $i++) {
            event(new UserRegisteredEvent("hi", "how are you", "alex@gmail.com"));
        }

final step is running queue

php artisan queue:work

Done

[2020-06-17 08:18:57][171] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:18:59][171] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:18:59][172] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:01][172] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:19:01][173] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:03][173] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:19:03][174] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:05][174] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:19:05][175] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:07][175] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:19:07][176] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:09][176] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:19:09][177] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:11][177] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:19:11][178] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:13][178] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:19:13][179] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:15][179] Processed:  App\Listeners\SendRegistrationEmail
[2020-06-17 08:19:15][180] Processing: App\Listeners\SendRegistrationEmail
Start sending email
Email sended to alex@gmail.com
[2020-06-17 08:19:17][180] Processed:  App\Listeners\SendRegistrationEmail

It works like a charm :)

Feel free to ask any questions

Forem: Mohammad Reza

From PHP to Go: Recognizing and Avoiding PHP-ish Patterns in Go Projects (part 2)

Overengineering: Bringing Laravel’s Complexity into Go

Introduction

1. Implementing Laravel's Service Container in Go

The Pitfall: Overcomplicating Dependency Injection

Embracing Go's Simplicity: Idiomatic Dependency Injection

2. Mimicking Eloquent ORM in Go

The Pitfall: Introducing Heavy ORM Abstractions

Embracing Go's Database Handling: Using database/sql and Lightweight Libraries

Using database/sql Effectively

Using Helper Libraries like sqlx for Convenience

Considering ORM Libraries Like GORM

Making an Informed Choice

3. Recreating Laravel's Routing and Middleware

The Pitfall: Overcomplicating HTTP Handling

Embracing Go's net/http: Simple and Effective

Utilizing Third-Party Routers When Needed

Conclusion

Additional Resources

From PHP to Go: Recognizing and Avoiding PHP-ish Patterns in Go Projects (part 1)

Introduction

Why Go Prefers Composition Over Inheritance

Scenario: A Task Execution System

Inheritance-Based Approach

Problems with the Inheritance Approach

Composition-Based Approach

Zero Down Time Deployment!

First Step

Let's go to the next interesting part

Now I want to show you what will happen if you just want to deploy the new code

Result

You can feel what is the problem right now so let's try to fix it

We want to use docker swarm

Result

let's make .gitlab-ci.yml for it

Step one

Step two

Step three

Step Four

Step five

Step six

Step seven , Done

How To Set Up an OpenVPN Server on Linux Server (Ubuntu)

You can easily follow this steps to have your own VPN on your server.

Login to the server without password

ci/cd with gitlab (part one)

In this article we try to just run a command from the pipline in our server

.gitlab-ci.yml

XDebug, VScode, ubuntu

1.Step one

2.Step two

3.Step three

Run docker commands without sudo :))

First create a docker group

Add the connected user $USER to the docker group

Done

Change php version

SSH Keys for GitHub (Debian GNU/Linux)

Go to Account Settings > Ssh keys and pase what you have been copied

Define your own facade in laravel

In this article I want to make SmartLogger class and try to use it with Facades so lets start

Create a directory in app and which has SmartLogger name and fill it like below

SmartLogger.php

SmartLoggerFacade.php

lets make service provider

SmartLoggerServiceProvider.php

Now open config\app.php and add this lines in it

Now lets test it :)

Feel free to ask any questions :)

Laravel Events

Lets start

UserRegisteredEvent.php

EventServiceProvider.php

Now add somethings like this in your controller for example

final step is running queue

Done

It works like a charm :)

Embracing Go's Database Handling: Using `database/sql` and Lightweight Libraries

Using `database/sql` Effectively

Using Helper Libraries like `sqlx` for Convenience

Embracing Go's `net/http`: Simple and Effective