DEV Community: TekniksMila

Building a Web Server in Go

TekniksMila — Mon, 04 Mar 2024 19:24:26 +0000

Introduction

A server is a specialized system whose role is to respond to requests made by computers over a network. Servers are very critical since they provide hosting for websites and applications, and they also facilitate communication over a network. In this article, let's dive into creating a simple HTTP server that serves files and handles form submissions and requests to specific endpoints.

Prerequisite:

Basic understanding of Go and web development concepts.
Must have Go installed. If you do not have Go installed, first navigate here to install Go.

Project directory structure

Open terminal.
Create a directory with the name 'WebServer'.
Navigate into the 'WebServer' directory.
Initialize a new Go module.
Create a file with the name 'main.go'.
Create a new directory inside the 'WebServer' directory and name it 'files'.
Navigate into the files directory.
Create two files with the names index.html and form.html.

 mkdir WebServer
 cd WebServer
 go mod init example/WebServer
 touch main.go
 mkdir files
 cd files
 touch index.html
 touch form.html

```
## The code
* Open the index.html file and write the code as shown below. This will display a static web page.

````html
  <html>
      <head>
          <title>static website</title>        
      </head>
      <body>
          <h2>static website</h2>
      </body>
  </html>

```
* Open the form.html file and write the code as shown below: When rendered, this will display a form with name and address text fields.

````html
  <!DOCTYPE html>
  <html>
      <head>
          <meta charset = "UTF-8"/>
      </head>
      <body>
          <div>
              <form method="POST" action="/form">
              <label>Name</label><input name="name" type="text" value=""/>
              <label>Address</label><input name="address" type="text" value=""/>

              <input type="submit" value="submit"/>
              </form>
          </div>
      </body>
  </html>

```
* Open main.go. Here we start off by declaring the main package, then import the packages that are necessary for the working of our program.

````go
  package main

  import (
      "fmt"
      "log"      // Importing the log package for logging
      "net/http" // Importing the net/http package for HTTP server functionality
  )

````go
* Next we create a function that handles form submissions.

`````go
func formHandler(w http.ResponseWriter, r *http.Request) {
    // ParseForm parses the raw query from the URL and updates r.Form
    if err := r.ParseForm(); err != nil {
        fmt.Fprintf(w, "ParseForm() err: %v", err)
        return
    }
    fmt.Fprintf(w, "POST request successful")
    name := r.FormValue("name")               // Retrieve the value of the 'name' parameter from the form
    address := r.FormValue("address")         // Retrieve the value of the 'address' parameter from the form
    fmt.Fprintf(w, "Name = %s\n", name)       // Print the name to the response writer
    fmt.Fprintf(w, "Address = %s\n", address) // Print the address to the response writer
}

```
* Create a function that handles requests to the /hello endpoint.

````go
func helloHandler(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/hello" {
        http.Error(w, "404 not found", http.StatusNotFound)
        return
    }
    if r.Method != "GET" {
        http.Error(w, "method is not supported", http.StatusNotFound)
        return
    }
    fmt.Fprintf(w, "hello!") // Respond with "hello!" for GET requests to /hello endpoint
}

```
* Create a main function that defines a simple HTTP server that serves static files from the ./files directory and handles requests to specific endpoints (/form and /hello) with custom handler functions.

````go
func main() {
    fileServer := http.FileServer(http.Dir("./files"))
    // Create a file server handler for serving static files from ./files directory
    http.Handle("/", fileServer)            // Handle requests to root path with fileServer handler
    http.HandleFunc("/form", formHandler)   // Handle requests to /form endpoint with formHandler function
    http.HandleFunc("/hello", helloHandler) // Handle requests to /hello endpoint with helloHandler function

    fmt.Printf("Starting server at port 8080\n")

    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatal(err) // Log any errors that occur during server startup and exit with error status
    }
}

```
## Executing the program
* Save the files you have created.

* On the terminal type the following command:

````bash
go run main.go

```
* When you see "Starting server at port 8080" displayed on the terminal, head over to your browser and search "localhost://8080/".

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x83il13okhguxzbigvm6.png)

* Open new tab on your browser and search"localhost:8080/form.html".
* A form as the one shown below will be displayed.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bz0i9v7ox5zp1kk6jtdc.png)

* Upon submitting the form after filling in the name and address field, the following message is displayed.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/t22b2zv0ix944r5z57i2.png)

* This shows that our web server is working as expected.

## Resources
* Find the GitHub repository on this [](https://github.com/JosephOkumu/WebServer)

Building a URL Shortener in Go: A Step-by-Step Guide

TekniksMila — Sun, 03 Mar 2024 21:06:56 +0000

Introduction

A server is a specialized system whose role is to respond to requests made by computers over a network. Servers are very critical since they provide hosting for websites and applications, and they also facilitate communication over a network. In this article, let's dive into creating a simple HTTP server that serves files and handles form submissions and requests to specific endpoints.
Prerequisites

Basic understanding of Go and web development concepts.

Must have Go installed. If you do not have Go installed, first navigate here https://go.dev/doc/manage-install to install Go.

Project directory structure

Open terminal.

Create a directory with the name 'WebServer'.

Navigate into the 'WebServer' directory.

Initialize a new Go module.

Create a file with the name 'main.go'.

Create a new directory inside the 'WebServer' directory and name it 'files'.

Navigate into the files directory.

Create two files with the names index.html and form.html.

 mkdir WebServer
 cd WebServer
 go mod init example/WebServer
 touch main.go
 mkdir files
 cd files
 touch index.html
 touch form.html

The code

Open the index.html file and write the code as shown below. This will display a static web page.

static website

Open the form.html file and write the code as shown below: When rendered, this will display a form with name and address text fields.

<!DOCTYPE html>

Name
Address

          <input type="submit" value="submit"/>
          </form>
      </div>
  </body>

Open main.go. Here we start off by declaring the main package, then import the packages that are necessary for the working of our program.

  package main

  import (
      "fmt"
      "log"      // Importing the log package for logging
      "net/http" // Importing the net/http package for HTTP server functionality
  )

Next we create a function that handles form submissions.

func formHandler(w http.ResponseWriter, r *http.Request) {
// ParseForm parses the raw query from the URL and updates r.Form
if err := r.ParseForm(); err != nil {
fmt.Fprintf(w, "ParseForm() err: %v", err)
return
}
fmt.Fprintf(w, "POST request successful")
name := r.FormValue("name") // Retrieve the value of the 'name' parameter from the form
address := r.FormValue("address") // Retrieve the value of the 'address' parameter from the form
fmt.Fprintf(w, "Name = %s\n", name) // Print the name to the response writer
fmt.Fprintf(w, "Address = %s\n", address) // Print the address to the response writer
}

Create a function that handles requests to the /hello endpoint.

func helloHandler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/hello" {
http.Error(w, "404 not found", http.StatusNotFound)
return
}
if r.Method != "GET" {
http.Error(w, "method is not supported", http.StatusNotFound)
return
}
fmt.Fprintf(w, "hello!") // Respond with "hello!" for GET requests to /hello endpoint
}

Create a main function that defines a simple HTTP server that serves static files from the ./files directory and handles requests to specific endpoints (/form and /hello) with custom handler functions.

func main() {
fileServer := http.FileServer(http.Dir("./files"))
// Create a file server handler for serving static files from ./files directory
http.Handle("/", fileServer) // Handle requests to root path with fileServer handler
http.HandleFunc("/form", formHandler) // Handle requests to /form endpoint with formHandler function
http.HandleFunc("/hello", helloHandler) // Handle requests to /hello endpoint with helloHandler function

fmt.Printf("Starting server at port 8080\n")

if err := http.ListenAndServe(":8080", nil); err != nil {
    log.Fatal(err) // Log any errors that occur during server startup and exit with error status
}

}

Executing the program

Save the files you have created.

On the terminal type the following command:

go run main.go

When you see "Starting server at port 8080" displayed on the terminal, head over to your browser and search "localhost:8080".

Open new tab on your browser and search "localhost:8080/form.html".

A form as the one shown below will be displayed.

Upon submitting the form after filling in the name and address field, the following message is displayed.

This shows that our web server is working as expected.

Resources

Find the code in my GitHub repository. Here is the link

https://github.com/JosephOkumu/WebServer

Building a URL Shortener in Go: A Step-by-Step Guide

TekniksMila — Sat, 24 Feb 2024 23:02:28 +0000

Introduction:

URL shortening is a technique used used to convert lengthy and complex URLs into shorter user-friendly versions. These shortened URLs are preferably advantageous compared to the original URLs, since they reduce visual complexity of the original URLs making them easier to read and remember thus promoting user engagement and click-through rates. Additionally, shortened URLs can be easily shared on spaces where available space is limited.
In this article I am going to walk you through the process of building a URL shortener in Go.

Prerequisites:

Basic understanding of Go, HTTP servers and web development concepts.
You must have Go installed in your computer system. If you do not have Go installed, first navigate to link to install Go.

Creating Project Directory and files:

Open terminal, create a project directory and name it "URL-Shortener".
Navigate inside the "URL-Shortener" directory.
Initialize a new Go module.
Create a main.go file. Make sure the commands are entered line by line as shown below.

mkdir URL-Shortener
cd URL-Shortener
git mod init url-shortener
code main.go

Writing the Go code:

Open the main.go file. This is where you will write the code.
Start off by declaring the main package. Import the necessary packages for running the program. "fmt" for formatting and printing, "math/rand" is for random number generation, "net/http" is for HTTP server functionality, "strings" is for string manipulation, and "time" for time-related functions.

package main
import (
    "fmt"
    "math/rand"
    "net/http"
    "strings"
    "time"
)

Create a global variable "ShortURLs" which is a map that will store the shortened URLs of type string as key, and their corresponding original URLs of type string as value.

// ShortURLs is a map that stores shortened URLs with their corresponding original URLs.
var shortURLs = make(map[string]string)

The main function sets up HTTP request handlers for different endpoints and starts the HTTP server on port 3030. The http.handleFunc() is used to map HTTP request paths to corresponding handler functions.

func main() {
    // Set up HTTP request handlers
    http.HandleFunc("/", handleForm)           //Handle root endpoint
    http.HandleFunc("/shorten", handleShorten) // Handle URL shortening endpoint
    http.HandleFunc("/short/", handleRedirect) // Handle redirecting to original URL

    // Start HTTP server
    fmt.Println("URL Shortener running on: 3030")
    http.ListenAndServe(":3030", nil)
}

The handleForm function is the handler function for GET requests to the root endpoint ("/"). It displays an HTML form for submitting a URL that needs to be shortened.

// handleForm handles GET requests to the root endpoint and displays the URL shortening form
func handleForm(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPost {
        http.Redirect(w, r, "/shorten", http.StatusSeeOther)
        return
    }

    w.Header().Set("Content-type", "text/html")
    fmt.Fprint(w, `
        <!DOCTYPE html>
        <html>
        <head>
            <title> URL-Shortener</title>
        </head>
        <body>
            <h2>URL-Shortener</h2>
            <form method= "post" action="/shorten">
                <input type="url" name="url" placeholder="Enter a URL" required>
                <input type="submit" value="Shorten">
            </form> 
        </body>
        </html>
    `)
}

The handleShorten function is the handler for POST requests to the "/shorten" endpoint. It generates a shortened URL, stores the URL and its original counterpart in a map and renders an HTML response that displays both URLs.

// handleShorten handles POST requests to the /shorten endpoint and generates a shortened URL
func handleShorten(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
        return
    }

    // Get the original URL from the form
    originalURL := r.FormValue("url")
    if originalURL == "" {
        http.Error(w, "URL parameter is missing", http.StatusBadRequest)
        return
    }

    // Generate a short key and store the original URL
    shortKey := generateShortKey()
    shortURLs[shortKey] = originalURL

    // Construct the shortened URL
    shortenedURL := fmt.Sprintf("http://localhost:3030/short/%s", shortKey)

    // Render HTML response with original and shortened URLs
    w.Header().Set("Content-Type", "text/html")
    fmt.Fprint(w, `
        <!DOCTYPE html>
        <html>
        <head>
            <title> URL-Shortener</title>
        </head>
        <body>
            <h2>URL-Shortener</h2>
            <p>Original URL: `, originalURL, `</p>
            <p>Shortened URL: <a href="`, shortenedURL, `">`, shortenedURL, `</a></p>
        </body>
        </html>
        `)
}

handleRedirect handles requests to shortened URLS ("/short"). It extracts the short key from the request path, looks up the original URL, and redirects the client to the original URL.

// handleRedirect handles requests to shortened URLs and redirects to the original URL.
func handleRedirect(w http.ResponseWriter, r *http.Request) {
    // Extract the short key from the request path
    shortKey := strings.TrimPrefix(r.URL.Path, "/short/")
    if shortKey == "" {
        http.Error(w, "Shortened key is missing", http.StatusBadRequest)
        return
    }

    // Retrieve the original URL from the map
    originalURL, found := shortURLs[shortKey]
    if !found {
        http.Error(w, "Shortened key not found", http.StatusNotFound)
        return
    }

    // Redirect to the orginal URL
    http.Redirect(w, r, originalURL, http.StatusMovedPermanently)
}

The generateShortKey function is responsible for generating a short random key for URL shortening. It uses a predefined character set and a key length of 6 characters to create the short key.

// generateShortKey generates a short random key for URL shortening
func generateShortKey() string {
    const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    const keyLength = 6

    rand.Seed(time.Now().UnixNano())
    shortKey := make([]byte, keyLength)
    for i := range shortKey {
        shortKey[i] = charset[rand.Intn(len(charset))]
    }
    return string(shortKey)
}

Executing the URL Shortener Program

Save the main.go file.
Run the program by typing on the terminal the command below:

go run main.go

It will display that the URL Shortener is running on port 3030.

URL Shortener running on: 3030

Open your browser and on the address bar type http://localhost:3030 then search.
Once the new page loads, enter the URL you want to shorten in the text field, and click the "shorten" button.
Find the shortened URL displayed on the screen.

Resources.

You can find the whole working code on my Github profile. Here is the link
Also find a short video demonstration showing the end result on Twitter. Here is the link

Surviving the Zone01 Software Development Piscine Bootcamp in Kenya

TekniksMila — Sat, 23 Dec 2023 12:53:36 +0000

Embarking on the Zone01 Piscine felt like diving into uncharted waters, a digital sea of challenges that promised to test the spirit of aspiring coders. The preliminary online test marked my initiation, a gateway to the grandeur of the piscine experience. Invitations were extended and I eagerly embraced the opportunity to dive into the first-ever Zone01 piscine in East Africa, a journey that would define my coding prowess.

Before diving into the coding abyss, a prelude unfolded, a check-in session where details of the program were revealed unto us. The piscine, a French term which refers to a swimming pool and is also associated with 42 school, involves immersing candidates to the deep end of the pool. The analogy struck hard, novice swimmers get thrust into the deep end and their survival is dependent on mastering the art of coding.

The dawning day of the piscine unleashed a torrent of challenges. A hundred pisciners were cast into the coding sea. Each day timed coding exercises synonymous to turbulent tides demanded resilience. The exercises tricky and daunting, required days of commitment, a marathon where completion was a victory unto itself.

Sundays brought forth checkpoints which involved four hours of scrutiny to test the evolving coding prowess of the candidates. Immediately after the checkpoints collaborative coding tasks akin to synchronized swimming followed, a team effort in the turbulent waters of coding complexity. As the weeks passed by, the waves became relentless and unforgiving. By end of week two the piscine’s intensity weeded out the wavering leaving behind seventy-something of us who were resilient and undeterred, clinging to the hope of reaching the piscine’s shore.

The climax of the piscine came in the form of a final checkpoint, an eight-hour marathon with 11 coding questions. I managed to tackle up to question six in the checkpoint and like a swimmer momentarily overwhelmed by the depths, I faced a formidable question seven that left me gasping for breath. The piscine concluded, we exchanged farewells and dispersed awaiting the verdict that lingered on the horizon.

Anticipation gripped us for two weeks, and then like a beacon on a stormy night, the email arrived. Success! The journey through the piscine’s depths had yielded triumph. Out of a hundred, only 28 were selected for the program, and I was among them. The dream of being a full stack developer is in the offing, courtesy of the Zone01 program.

To those daring to plunge into the piscine’s waters, remain cognizant of these insightful tips: Embrace the intensity; perseverance is your anchor. Learn ceaselessly for knowledge is the compass steering you through the coding currents. Do not compare or compete with others, be true to yourself. Sacrifice sleep for the sake of code; there are no shortcuts in the piscine. Last but not least, character matters. Honesty and integrity will help you navigate the currents of the selection. To future pisciners, may the code be ever in your favor.