Wij houden van web performance. Het is 2019, er is geen excuus voor een slecht presterende website.
Maar wat is performance en waarom heeft het impact op jouw Google resultaten? En wat kan je doen om de performance van jouw website te verbeteren?

WordPress en Woocommerce maximaal laten presteren

De performance van een WordPress website of een Woocommerce webshop hangt af van de volgende punten.

  1. De kwaliteit van webhosting.
    Voldoet deze aan de moderne eisen? Is er ondersteuning voor de snelste protocollen en techniek? etc.
  2. De inhoud van de website.
    Het aantal plaatjes, het aantal externe links, maakt de website gebruik van lazy loading? etc.
  3. Het optimalisatie proces.
    Hoe worden plaatjes opgeslagen, staan de cache instellingen juist? etc.

Wat kan je doen om deze performance te verbeteren en waar moet je op letten? Het begint bij de motor.


De kwaliteit van webhosting

motor
Performance begint bij de motor

Laten we beginnen met de webhosting, dit is namelijk de motor van jouw website. Als deze niet krachtig genoeg is of niet goed wordt onderhouden, dan heeft dat direct impact.

Shared hosting is over het algemeen niet geoptimaliseerde hosting; de insteek is anders omdat shared hosting gemaakt is om kosten te beperken en winst te maximaliseren.

Veel websites draaien op shared hosting, hosting waarbij meerdere websites draaien op hetzelfde systeem. Het is populair en dat is begrijpelijk want de prijs/performance verhouding is doorgaans goed. Wil je echter een groter publiek aanspreken dan adviseren we je om over te stappen naar een eigen server.

Waar moet je op letten bij webhosting?

  • Ondersteuning voor het HTTP2 protocol.
    Dit protocol is momenteel het snelste protocol om websites beschikbaar mee te maken.
  • Veilige en moderne SSL verbinding.
    SSL zorgt ervoor dat gegevens tussen bezoeker en jouw website niet kunnen worden gelezen door anderen.
  • Ondersteuning voor gzip en Brotli compressie.
    Door gebruikt te maken van compressie kan je de bestanden op jouw website tot wel 80% kleiner maken.
  • Zorg voor de juiste cache headers.
    Cache headers geven de browser instructies om delen van de website tijdelijk op te mogen slaan, de bezoeker krijgt hierdoor een snellere website.
  • Maak gebruik van server-side caching.
    Systemen zoals WordPress en Woocommerce worden vaak bij ieder bezoek dynamisch opgebouwd. Met server-side caching sla je dit proces over waardoor de server sneller kan leveren.
  • Maak gebruik van goed presterende DNS.
    DNS is het telefoonboek van internet. Iedere bezoeker gebruikt het om het adres van jouw website te kunnen vertalen naar een internet adres (IP). Een trage DNS zorgt ervoor dat bezoekers extra moeten wachten.
  • Ondersteuning voor Redis/Memcached.
    Redis en memcached zorgen ervoor dat WordPress en Woocommerce resultaten uit de database tijdelijk kunnen opslaan, dit versnelt aanzienlijk.

De inhoud van de website

even lastig als leuk
Deze welpjes zijn opgeslagen in het moderne .webp formaat, het maakt ze daardoor liever voor de performance

De content van jouw website heeft een grote invloed op de performance. Je moet hierin op zoek gaan naar balans, het is duidelijk dat een plaatje zwaarder weegt dan tekst.

Een supersnelle website is een lege website, belangrijk is om de balans te vinden tussen content en snelheid. Een gouden regel hierbij is dat een website onder de 2 seconde ingeladen moet zijn. (ook op mobiel!)

Hoe versnel ik de performance van mijn website?

  • Minimaliseer css, html en js assets.
    Door deze bestanden te minimaliseren bespaar je veel op dataverkeer, minder dataverkeer zorgt voor een snellere website.
  • Beperk het aantal requests.
    Door bestanden slim te combineren kan je het aantal requests beperken en dat heeft invloed op de snelheid.
  • Maak gebruik van lazy loading.
    Lazy loading zorgt ervoor dat de website de plaatjes pas laat zien als dat echt nodig is, hiermee bespaar je onnodige requests.
  • Maak gebruik van een CDN.
    Een Content Delivery Network kan ervoor zorgen dat jouw website sneller word. CDN’s zijn geoptimaliseerd voor performance en besparen requests naar de webserver.
  • Hanteer de 2 seconde regel.
    Een website moet binnen 2 seconde ingeladen zijn, langer wordt door de bezoeker gezien als hinderlijk. Optimaliseer je content hiernaar, zeker op de index pagina!
  • Vervang jpg png en gif afbeeldingen door WebP variant.
    WebP is een modern compressie formaat waarmee afbeeldingen aanzienlijk kleiner kunnen worden gemaakt.
  • Responsive design.
    Let erop dat mobile first belangrijk is, optimaliseer je content voor slechte verbindingen en oude telefoons, test dit ook regelmatig.

Het optimalisatie process

koffie?
We vinden het leuk om de performance van websites te verbeteren, we zijn hierin ervaren experts.

Google kijkt kritisch naar de performance van jouw website en bepaalt daarbij de relevantie voor de bezoeker. Is de website beschikbaar via https? Werkt deze goed op mobiel? En is de snelheid in orde?

Logisch eigenlijk want deze factoren bepalen voor een groot deel of jij als bezoeker wel krijgt wat je verwacht.

Controleer de performance van jouw website.

  • securityheaders.com controleert of jouw website wel voldoet aan moderne veiligheidsnormen.
  • ssllabs.com voert https controles uit, let op dat de score minimaal een A moet zijn.
  • web.dev van Google voert performance checks uit en laat verbeter punten zien.

De performance van de meeste websites valt flink te verbeteren, we adviseren je om hier kritisch naar te kijken en dat te blijven doen. Het web verandert snel.

Tot slot, er zijn diverse WordPress plugins die de de performance van jouw WordPress website of Woocommerce webshop flink kunnen verbeteren. Een van onze favorieten is autoptimize, deze plugin verbetert de prestaties zoals genoemd in de eerste drie punten zoals beschreven bij punt 2. Een andere tip is gebruik te maken van ReSmushIT waarmee je afbeeldingen verder kunt verkleinen.

codar levert geoptimaliseerde webhosting op basis van de modernste techniek, we helpen je graag met het verbeteren van de performance van jouw website. We lopen voorop in het toepassen van de nieuwste techniek!

Neem contact met ons op.

Introduction

Mobile internet is huge and it brings back old “friends” like flaky latency and slow downloads. A faster site is a greater joy, so time for us to improve and add both Brotli and WebP support to our hosting platform..

codar is web performance, always looking for ways to improve your website speedindex. In this blog I’ll describe our experience with Webp and Brotli, both web techniques that create smaller files for a faster website. (and a better SEO score!)


What is WebP?

WebP is a modern image format that provides superior lossless and lossy compression for images on the web. Using WebP, webmasters and web developers can create smaller, richer images that make the web faster.

WebP lossless images are 26% smaller in size compared to PNGs. WebP lossy images are 25-34% smaller than comparable JPEG images at equivalent SSIM quality index.

Lossless WebP supports transparency (also known as alpha channel) at a cost of just 22% additional bytes. For cases when lossy RGB compression is acceptable, lossy WebP also supports transparency, typically providing 3× smaller file sizes compared to PNG.

source: https://developers.google.com/speed/webp

What is Brotli?

Brotli is a modern open-source compression algorithm developed by Google to help further reduce the size of files. It is used as a server technique to transparently compress files for the visitor to allow smaller, and thus quicker, transfers.

Here are a few of the highlights that make Brotli a leader in compression:

  • Brotli is independent of CPU type, operating system, file system, and character set.
  • It can produce a compression ratio that is comparable to the best compression methods currently available and most importantly is considerably better than Gzip.
  • It decompresses much faster than current LZMA implementation.

source: https://github.com/google/brotli/

Supported by all modern browsers enabled by default

Brotli and WebP will make your website faster and increase your Google speedindex score!

Recently we transparently enabled both WebP and Brotli support on our hosting platform. The results have been great, at least 20% smaller files on average and a big improvement on our Google Insight score!

Speed-as-a-Service

But the best thing is that you don’t need to do anything when hosting on our platform! We updated our systems to transparently encode all applicable images to the smaller and more efficient WebP format while retaining your original images. Our webservers will serve WebP to modern browsers while preserving original images for incompatible browsers. This works for all websites and webshops, no plugins needed! (note: you can always enable and disable this feature.)

So sit back, relax and enjoy technology!

Test you website performance

Test the performance of your website with https://web.dev

WebP and Brotli are great for smaller and faster websites, curious if your website will benefit from this? Let us help you in getting the best website performance.

Stay tuned..

This article will guide you setting up Container Linux (CoreOS) for Kubernetes.

Introduction

Kubernetes can run on almost any host supporting Docker, even on devices like the Raspberry PI. Personally I like Container Linux because it’s lightweight and practically maintenance free after setup. (compared to classic OS’es like Ubuntu or Debian). It’s an OS created specifically for container workloads and it has been a huge contributor to the succes of Kuberentes with techniques like “etcd”.


Hardware

Let’s run this cluster on at least 2 nodes, make sure they have at least 3G RAM each, both should have at least 20G disks and have basic network connectivity, make sure both nodes can connect to the internet. VMware is nice for this setup, it’s what I used in this example, but you can also run this on Digital Ocean or any other cloud service that offers Container Linux images.

The great thing about Kubernetes is that it doesn’t care about the hardware, it could be AWS combined with a Raspberry PI and VMware. In this article we focus on x64 architecture since Container Linux doesn’t run on ARM.

Starting Container Linux

There are a few ways to install Container Linux, but you’ll need to set a password at least to be able to login. I run Container Linux booted via iPXE with an ignition file. It allows me to configure basic features like the hostname and openssh public keys etc. I think you can paste this file on a webserver and refer to it using boot options when booting from ISO.

The ignition file sets up authentication, but also some other small settings recommended for Kubernetes.

{
  "ignition": { "version": "2.2.0" },
  "storage": {
    "files": [
        {
              "filesystem": "root",
              "path": "/etc/hostname",
              "mode": 420,
              "contents": {
                        "source": "data:,core1"
                }
        },
        {
        "filesystem": "root",
        "group": {},
        "path": "/etc/sysctl.d/local.conf",
        "user": {},
        "contents": {
          "source": "data:,net.netfilter.nf_conntrack_max%3D131072",
          "verification": {}
        },
        "mode": 420
        }
        ]
  },
  "passwd": {
    "users": [
      {
        "name": "core",
        "passwordHash": "$6--REDACTED--0 (create a password hash using Linux for example)",
        "sshAuthorizedKeys": [
          "ssh-rsa VL--REDACTED--Z0z="
        ]
      }
    ]
  }
}

Ignition files have many options and technically it could perform all steps described in this article, but I like to show the steps required so you will better understand the components that are required.

Ignition files can be validated via the Container Linux website.

Installing Container Linux

The first thing you want to do is install Container Linux on the disk. In this example I install the integrated VMware drivers, note that the ignition file is used to set authentication options.

sudo coreos-install -d /dev/sda -o vmware_raw -i yourcustomignfile.ign -C stable

Reboot and you should see a boot menu appear shortly, indicating that installation was successful. After booting from disk change the hostname and configure the network, it is very important understand that both the hostname but also the IP address will be bound to the trust certificates used in Kubernetes! (I prefer reserved dhcp leases)

Both hostname and IP address will be used for certificate trust, changing them later is a pain!

I use the following names since I regard the master as a normal node.

  • kube1.domain.fqn
  • kube2.domain.fqn
  • etc.

Prepare the node for Kubernetes

The following steps describe the components required for a Kubernetes node, perform these steps as root and don’t bother about sudo.

Every node must have the kubelet service running, it is the heart of Kubernetes. It bootstraps the cluster and does low level network setup. It does all the low level work and depends on tools we need to install first. Since Kubernetes runs in Docker, it’s both the chicken and the egg basically.

All tools will run from /opt, Container Linux respects this path when upgrading.

Prepare the paths and set the release version

# set an ENV for later use, do NOT forget this part ;)
RELEASE="$(curl -sSL https://dl.k8s.io/release/stable.txt)"
CNI_VERSION="v0.7.4"

# directories
mkdir -p /opt/bin /opt/cni/bin /etc/systemd/system/kubelet.service.d

Install CNI, the Container Network Interface

First thing we need is CNI or Container Network Interface, it enables the kubelet service to setup and manage the Kubernetes network. Make sure CNI is installed in /opt/cni/bin and the files are executable before proceeding.

curl -L "https://github.com/containernetworking/plugins/releases/download/${CNI_VERSION}/cni-plugins-amd64-${CNI_VERSION}.tgz" | tar -C /opt/cni/bin -xz

Install low level Kubernetes tools

Next up are tools like crictl, kubelet, kubeadm and kubectl, these tools have no external dependencies making installation easy.

kubeadm: needed for low level node administration
kubelet: low level kubernetes bootstrapper
kubectl: user interface for Kubernetes
crictl: cri-o tool, part of cri-o containers

curl -L https://github.com/kubernetes-incubator/cri-tools/releases/download/${RELEASE}/crictl-${RELEASE}-linux-amd64.tar.gz | tar -C /opt/bin -xz

cd /opt/bin
curl -L --remote-name-all https://storage.googleapis.com/kubernetes-release/release/${RELEASE}/bin/linux/amd64/{kubeadm,kubelet,kubectl}
chmod +x /opt/bin/{kubeadm,kubelet,kubectl,crictl}

That’s basically it, now all we need to do is install and enable the kubelet service.

Kubelet is installed in /opt on Container Linux, we need to change that in the service file.

curl -sSL "https://raw.githubusercontent.com/kubernetes/kubernetes/${RELEASE}/build/debs/kubelet.service" | sed "s:/usr/bin:/opt/bin:g" > /etc/systemd/system/kubelet.service

# this is the systemd way of changing a service, it's elegant
mkdir -p /etc/systemd/system/kubelet.service.d
curl -sSL "https://raw.githubusercontent.com/kubernetes/kubernetes/${RELEASE}/build/debs/10-kubeadm.conf" | sed "s:/usr/bin:/opt/bin:g" > /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
# Update kubelet service to allow Container Linux volumeplugins
echo "KUBELET_EXTRA_ARGS=--volume-plugin-dir=/var/lib/kubelet/volumeplugins" > /etc/default/kubelet
# Almost done, enable services and reboot the node
systemctl enable docker
systemctl enable kubelet

Your node is ready

After this you can start installing Kubernetes with the kubeadm tool, this will be described in another blog.

Stay tuned..