Teknik
Välkommen till vår teknikblogg! Håll dig uppdaterad, följ oss på LinkedIn
Dynamic Multi Tenancy with Spring Boot, Hibernate and Liquibase Part 8: Shared Database pattern with Hibernate 6
// Björn Beskow
In part 5, we implemented the Shared Database with Discriminator Column pattern using Hibernate filters. Since then, Hibernate has implemented native support for Discriminator-based multitenancy. Hence in this final part, we’ll implement the Shared Database with Discriminator Column pattern using Hibernate 6 and Spring Boot 3.
The Role of Roles in Ansible - A path to local IaC part 2
// Henrik Starefors
This post is part two of dipping our toe into the ocean of Ansible.
In part 1 of this series, we reviewed the basics of Ansible, how to build and execute tasks, and how to create our first playbook to contain it all. If you missed it, you can find part one here
Managing APIs using Kong Gateway Part 3: Mutual TLS and Certificate-Bound Access Tokens
// Björn Beskow
In the first part, we implemented access control for a sample API using Kong plugins for OIDC and OAuth 2.0, and in the second part, we implemented access control using Mutual TLS. In this short post, we will combine OAuth 2.0 Client Credentials with Mutual TLS, which is a frequently used pattern.
Managing APIs using Kong Gateway Part 2: Securing an API using Mutual TLS and Access Control Lists
// Björn Beskow
In the last part, we implemented access control to a sample API using Kong plugins for OIDC and OAuth 2.0. In this post, we will instead use Mutual TLS, where an x509 client certificate is used to authenticate the client. We will combine that with an Access Control List, where information from the client certificate is used to grant access.
Creating a Public Key Infrastructure for development
// Björn Beskow
Since https now being the default protocol in modern browsers rather than plain http, it is often necessary to be able to use https in local development and test environments. While many tools bundles a mechanism for automatically create self-signed server certificates for https usage, it is often necessary to be able to create a full Public Key Infrastructure for the development environment, with a Certificate Authority (CA) issuing both server certificates (used for backend servers) and client certificates (used for Mutual TLS). In this short blog post, we’ll summarize the steps required to set up a development PKI using OpenSSL.
Managing APIs using Kong Gateway Part 1: Securing an API using OIDC and OAuth 2.0
// Björn Beskow
API gateways are becoming increasingly more popular, and for good reasons. As the number of APIs within an organisation grows, the amount of “plumbing” required to expose the APIs in a secure, efficient and maintainable way quickly becomes overwhelming. An API Gateway is an architectural pattern which introduces a transparent placeholder between API clients and the APIs, where Cross Cutting Concerns such as Access Control, Monitoring, Logging, Caching and Rate Limiting can be implemented. In this blog series, we’ll be demonstrating how to use Kong, one of the leading Open Source API Gateways, to add various common capabilities to an API.
ABCs of Ansible - A path to local IaC
// Henrik Starefors
This post is part one of a series about using Ansible to automate the setup of our local development environment. In this part, we will look at the building blocks of Ansible and write our first automation tasks.
Kafka and Go - distributed state
// Björn Gylling
How do you approach using Kafka to store your data when building a HTTP api? In this series we build an application which would traditionally be backed by a classic database, the basic ‘Create-Read-Update-Delete’ api. Instead of a traditional database we store our data in Kafka and over the series look at some of the issues with this approach and how you can solve them. If you want to read from the beginning, you can find Part 1 here.
Kafka and Go - consumer group
// Björn Gylling
How do you approach using Kafka to store your data when building a HTTP api? In this series we build an application which would traditionally be backed by a classic database, the basic ‘Create-Read-Update-Delete’ api. Instead of a traditional database we store our data in Kafka and over the series look at some of the issues with this approach and how you can solve them. If you want to read from the beginning, you can find Part 1 here.
Kafka and Go - producing messages
// Björn Gylling
How do you approach using Kafka to store your data when building a HTTP api? In this series we build an application which would traditionally be backed by a classic database, the basic ‘Create-Read-Update-Delete’ api. Instead of a traditional database we store our data in Kafka and over the series look at some of the issues with this approach and how you can solve them. If you want to read from the beginning, you can find Part 1 here.
Kafka and Go - consuming messages
// Björn Gylling
How do you approach using Kafka to store your data when building a HTTP api? In this series we build an application which would traditionally be backed by a classic database, the basic ‘Create-Read-Update-Delete’ api. Instead of a traditional database we store our data in Kafka and over the series look at some of the issues with this approach and how you can solve them.
A CHIP-8 interpreter with Rust and Go
// Erik Lupander
I recently stumbled upon this great guide on how to build a CHIP-8 interpreter from scratch. This blog post is a personal rambling on my experience learning a bit of Rust by implementing a CHIP-8 interpreter, with some comparison with Go thrown into the mix.
Develop, build and deploy microservices on Apple silicon (ARM64)
// Magnus Larsson
This is the third blog post describing how to update the tools and frameworks used in the 2’nd edition of my book. In this blog post, we will learn how to develop, build and deploy microservices on a Mac with Apple silicon, i.e., an ARM64-based computer.
Path tracing with Golang and OpenCL, part 2
// Erik Lupander
In this part, we’ll take a quick look at OpenCL in general and a bit deeper look at how to make Go play nicely with OpenCL.
Upgrade to Kubernetes 1.25 and Istio 1.15
// Magnus Larsson
This is the second blog post describing how to update the tools and frameworks used in the 2’nd edition of my book. In this blog post, we will focus on updating Kubernetes and Istio, but also update related development tools such as Docker Desktop and Minikube.
Upgrade to Spring Boot 2.7 and Spring Native 0.12
// Magnus Larsson
It has been a year since the 2’nd edition of my book on building microservices with Spring Boot, Spring Cloud, Kubernetes, and Istio was published. Since then, many new versions of the tools and frameworks used in the book have been released. In this and a few following blog posts, I will describe how to upgrade the source code in the book to use the latest versions.
Go Generics in functional style
// Erik Lupander
I recently needed to group, aggregate and filter some form data from our yearly tech radar (2021 installment, Swedish). Instead of coping with an ever-increasing amount of frustration with Google Sheets, I decided to massage the data using Go 1.18 and the lodash-inspired lo library.
Kafka Summit London 2022
// Andreas Mossljung
En rapport från Kafka Summit i London som avslutades i går. Äntligen gick det att träffas på riktigt efter alla online-konferenser och vi var över 1000 deltagare som samlats på hotellet i Greenwich. Pandemin verkar man nu definitivt lämnat bakom sig i England och förutom några få som bar munskydd var allt som vanligt igen.
Henrik har tagit en Kubernetes-certifiering
// Henrik Starefors
Anders Forssell ställer några frågor till Henrik Starefors som nyss tagit en Kubernetes-certifiering.
Dynamic Multi Tenancy with Spring Boot, Hibernate and Liquibase Part 7: Combining the Shared Database pattern with Database per Group of Tenants (a.k.a. Shard) for additional scalability
// Björn Beskow
In the last part, we implemented the Shared Database with Discriminator Column pattern using Row Level Security. The Shared Database with Discriminator pattern scales very well, but eventually the Shared Database will become a bottleneck. In this part, we’ll tweak the Database per Tenant pattern into Database per Group of Tenants (or Shard). Combined with the Shared Database with Discriminator pattern, we can reach yet another level of scalability.