Integralist

TLS, Certificate, and ACME Glossary

This glossary defines common terms related to Transport Layer Security (TLS), digital certificates, Certificate Authorities (CAs), and the Automatic Certificate Management Environment (ACME) protocol. It's intended to help users understand the concepts involved in securing services and using APIs that manage certificate issuance, particularly focusing on Subject Alternative Names (SANs).

• Core Concepts
• Certificate Details

Integralist

https://pkg.go.dev/tailscale.com/util/ctxkey

Example Playground: https://play.golang.com/p/aZ0joNec3Xl

package main

import (
	"context"
	"fmt"

Integralist

DNS Management and Delegation

If a domain owner wants to use another company for handling DNS management over its domain, then they can update the "Name Servers" for their domain wherever DNS is currently managed, and set the Name Servers to a different DNS provider.

This is known as DNS delegation.

Once that Name Server change has propagated, the new DNS provider will be responsible for managing DNS records for the domain.

CNAME redirection magic

Integralist

.
├── Makefile
├── cmd
│   └── api
│       └── main.go
├── go.mod
├── go.sum
├── internal
│   ├── api

Integralist

// Package gob manages streams of gobs - binary values exchanged between an Encoder
// (transmitter) and a Decoder (receiver).
package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"log"
)

Integralist

Outcome

Implementation

# digg adds colors to the standard dig output to improve readability while not losing contextual information.
#
DIG_COMMENT_COLOR_SINGLE="\e[38;5;8m"  # Dark grey text, no background, no bold

Integralist

.well-known is a standardized path on a website's root domain that allows services to access metadata and configurations related to that domain. It's defined by RFC 5785.

The IANA (Internet Assigned Numbers Authority) maintains a registry of well-known URIs, ensuring that these paths are standardized and avoid conflicts.

Integralist

What's a ring buffer?

Ring buffers are known by a few names, such as circular queues and circular buffers.

A ring buffer is a fixed-size, circular data structure that overwrites the oldest data when the buffer is full. It’s particularly useful for scenarios where you want to store and retrieve data in a FIFO (First-In-First-Out) manner but with limited memory. When the buffer reaches its size limit, new data will overwrite the oldest data.

Instead of adding on the end and popping from the end, like a stack, you can add to one end and remove from the start, like a queue. And as you add or remove things, the start and end pointers move around. By managing these pointers, a ring buffer naturally enforces the FIFO order.

What's the benefit?

Integralist

# install dependencies
brew install graphviz plantuml librsvg

# generate puml file for entire project
go run github.com/jfeliu007/goplantuml/cmd/goplantuml@latest -recursive ./ > Example.puml

# generate SVG from entire project
plantuml Example.puml -o "$pwd" -tsvg

# convert SVG into a PDF

Integralist

package main

import (
	"context"
	"errors"
	"fmt"
	"math"
	"time"
)