Rewrite: A Simple and Powerful URL Rewriter for Go
Tags: webdev, go, networking, tutorial
Published: 2023-07-09 13:56:09

Rewrite is a Go package that lets you rewrite URL paths, subdomains or hosts based on regular expressions. It is inspired by Apache's mod_rewrite module and can be used as a middleware for [net/http](https://pkg.go.dev/net/http).

Rewrite can help you achieve better SEO results by redirecting old or unwanted URLs to new ones, enforcing a primary subdomain, or simplifying complex URL structures.

## How to Install Rewrite

To install Rewrite, you need to have Go installed on your system. Then, you can use the go get command to download and install the package:

```bash
$ go get github.com/kataras/rewrite
```

## How to Use Rewrite

You can load rewrite options in two ways:

1. Through code using the `New` function and `Handler` method. This way, you can handle parse errors and create rules programmatically.
2. Or through a YAML file using the `Load` function which returns a `func(http.Handler) http.Handler`. This is the most common and simplest way. It panics on parse errors.

The syntax of the rewrite rules is:

```
REDIRECT_CODE_DIGITS PATTERN_REGEX TARGET_REPL
```

Where:

- `REDIRECT_CODE_DIGITS` is the HTTP status code to use for the redirection, such as 301 (Moved Permanently) or 302 (Found).
- `PATTERN_REGEX` is the regular expression that matches the request URL path, subdomain or host.
- `TARGET_REPL` is the replacement string that contains the new URL path, subdomain or host.

For example:

```
301 /seo/(.*) /$1
```

This rule redirects all requests from relative path `/seo/*` to `/*` using the 301 HTTP status code.

You can also use a special option called `PrimarySubdomain` to redirect all requests from the root domain to a specific subdomain, such as `www`.

For example:

```
PrimarySubdomain: www
```

This option redirects all requests from `example.com` to `www.example.com`.

## Examples

Let's write a simple application that follows these redirect rules:

- Redirects `/seo/*` to `/*`
- Redirects `/docs/v12*` to `/docs`
- Redirects `/old (.*)` to `/`
- Redirects root domain requests to `www.`

The code would look like this:

```go
package main

import (
	"net/http"

	"github.com/kataras/rewrite"
)

func main() {
	mux := http.NewServeMux()
	// [...routes]

	// Load the redirect rules from a YAML file.
	redirects := rewrite.Load("redirects.yml")

	// Wrap the router with the rewrite middleware.
	http.ListenAndServe(":8080", redirects(mux))
}
```

The YAML file would look like this:

```yaml
RedirectMatch:
  # Redirects /seo/* to /*
  - 301 /seo/(.*) /$1
  # Redirects /docs/v12* to /docs
  - 301 /docs/v12(.*) /docs
  # Redirects /old (.*) to /
  - 301 /old(.*) /
# Redirects root domain requests to www.
PrimarySubdomain: www
```

That's it! Now you can test your application and see how it redirects the requests according to your rules.

You can find more examples in the `_examples` folder of the GitHub repository: https://github.com/kataras/rewrite/tree/main/_examples

## Conclusion

Rewrite is a handy package that lets you rewrite URLs in Go with ease. It is compatible with any net/http router or framework and supports regular expressions for flexible matching and replacing. It can help you improve your SEO performance by redirecting old or unwanted URLs to new ones, enforcing a primary subdomain, or simplifying complex URL structures.

If you want to learn more about Rewrite, you can check out its GitHub repository: https://github.com/kataras/rewrite

I hope you enjoyed this article and found it useful. If you have any feedback or questions, feel free to leave a comment below. Thank you for reading! 😊