DEV Community: Victor Darkes

Popular Kotlin Server-Side Libraries

Victor Darkes — Sun, 22 Nov 2020 02:11:08 +0000

Kotlin is a programming language for mobile cross-platform, native, data science, web, Android, and server-side development.

Kotlin for the Win

Kotlin is a great option for server-side development because it's a modern and concise take on JVM development. If you write Kotlin code there are advantages to using libraries written in Kotlin versus libraries written in Java. Here are some of those advantages.

There is less mental load when interacting with a Kotlin-specific library. That's because there is no context switching when you look at the source code of a library or are trying to debug a library feature. Additionally, Kotlin-specific library APIs are more idiomatic. In Kotlin functional programming is a first-class citizen. Many of these libraries lend themselves to functional programming over equivalent Java libraries meant for object oriented programming. Finally, you can avoid Kotlin platform types. Kotlin platform types appear when you reference Java code from within Kotlin code. The type is not guaranteed as nullable or non-nullable, so you can still run into null pointer exceptions. With all that said, here is a list of popular libraries written in Kotlin.

Web

Ktor - A Kotlin web framework that has the most GitHub stars relative to other options. Can be used with a variety of the other options mentioned in this article.

http4k - A simple and functional HTTP client and server.

Kotless - A Kotlin serverless framework.

Testing

Mockk - A Kotlin mocking library. Mocking is commonly done when writing unit tests. Usually what isn't being tested is what you mock so that your individual test can focus on one function.

Mockito Kotlin - If you're familiar with the Java Mockito library, then this one might be the right choice for you.

Spek - A good option if you're a fan of Jest.

Documentation

Dokka - The official documentation engine for Kotlin. It performs the same role as javadoc in Java.

Dependency Injection

Koin - Has more GitHub stars of the two options. It has a simpler API.

Kodein - A more robust API. Supports Kotlin multiplatform.

Database

Exposed - A Kotlin SQL ORM framework. It supports 7 different databases, including MySQL, PostgreSQL, and MariaDB.

SQLDelight - Generates type-safe Kotlin models from your SQL statements.

Miscellaneous

Okio - An I/O library. If you need to read or write data to a filesystem this is the library for you.

Conclusion

There are a lot of different options for writing server-side Kotlin code. Additionally, many of these libraries are useful for more than just server-side development. Since Kotlin was first released, the ecosystem has matured and provides a lot of different options for Kotlin developers.

If you use Kotlin do make an effort to use libraries written in Kotlin? Or does it not matter to you? Let me know in the comments.

Infrastructure as Code Explained

Victor Darkes — Thu, 12 Nov 2020 20:36:29 +0000

What is Infrastructure?

Infrastructure is all the necessary underlining technology that supports your running application. Examples include a server, database or private network.

Before the popularity of cloud all this underlining technology was managed locally. Someone would have to be physically responsible for software updates and upgrades. Now the high adoption of cloud infrastructure allows for their creation in a cloud providers console with a few clicks. Initially it may seem easy to manage all the cloud resources you have.

Why Manage Infrastructure With Code?

As you scale or work on larger projects it can be hard to manage all your cloud resources and prices can increase quickly. Infrastructure as Code (IaC) allows you to provision and manage any cloud, infrastructure, or service with code. IaC provides visibility into what resources are being used. That makes it easier to keep track of changes that occur. Using code also allows for automation to play a larger role in your workflow. That removes potential human errors. IaC also standardizes cloud resources because now there shouldn't be any differences between individual servers.

List of Popular Tools

Chef - Uses a Ruby Domain Specific Language (DSL).
Otter - A Windows-oriented solution.
Puppet - Uses proprietary declarative Puppet DSL that's Ruby based.
SaltStack - Acquired by VMWare in 2020. 3rd Most GitHub stars.
CFEngine - The oldest of the group. Used by LinkedIn and Samsung.
Terraform - The one I personally use. Newest of the group and has the 2nd most GitHub star.
Ansible - Acquired by Red Hat in 2015 and ships with the Linux Fedora operation system. Most GitHub stars.
AWS CloudFormation - AWS-only resources can be managed.

The Difference

Each of these has it's own approach. Here are some strengths and weaknesses between some of these offerings.

Configuration Management vs Provisioning - Is the IaC tooling more suited for managing software on existing servers or creating new servers?
Mutable vs Immutable infrastructure - When I make a change are existing resources modified or are new resources created?
procedural vs declarative - Programming style preference.
Agent vs Agentless - Does the server that is being configured need to install agent software?
Master vs Masterless - Does the IaC tooling need it's own server to run from?
Large vs Small community - Will it be easy for me to find support and resources?

It's best to check your requirements and choose a solution that meets your needs.

Conclusion

There isn't one perfect Infrastructure as Code solution out there. For simpler projects they aren't necessary. It can take longer to learn one of these than just provisioning resources yourself. But as you grow that approach does not scale. In an enterprise environment, Infrastructure as Code is vital for reducing costs, and errors, while increasing visibility across an organization, and consistency.

What's your experience with Infrastructure as Code?

All Redis Eviction Policies Cheatsheet & Explanation

Victor Darkes — Wed, 04 Nov 2020 17:07:09 +0000

What is Redis?

Redis is an open source, in-memory data store that can be used as a database, distributed cache and message broker. It supports strings, collections, along with other data structures. Redis allows atomic operations on these types, such as pushing an element to a list.

Why use Redis?

A common use case for Redis is as a distributed cache in a microservice-oriented architecture. Let's say you have a service that calls a third-party and only so many requests to the third-party can be made before you're rate limited. You can cache the third-party response in-memory, but typically you'll have multiple instances of your service so that doesn't scale. You can use a use a traditional database, but if the third-party data is being served in real time to end users, that increases latency which is bad. This is where Redis comes in. Redis supports lower latency than a traditional database, and also can be the single source of truth for all the instances of your service so there are less calls to the third-party.

In-Memory vs On-Disk

There are different types of computer memory. Accessing data in memory eliminates seek time when querying the data. Eliminated seek time provides faster reads than disk. If you can serve more requests using in-memory data that's a better experience for your end user.

What's an Eviction Policy

An eviction policy is a popular feature in caches. It defines when to remove items from the data store based on what is configured. Redis has 8 different eviction policies to choose from.

The Default Eviction Policy

You might be thinking, there's too many to choose from, I'll just use the default, but that is not very wise. The default is noeviction which means that when the memory is full, there will be no evictions and Redis will return an error. This is not ideal in any production scenario. It demonstrates why you should use one of the many other eviction policies which will not interrupt your production systems.

`allkeys` vs `volatile`

volatile means only keys with an expire set will be evicted. So you need to explicitly prepare entries for eviction. On the other hand, allkeys means that all keys are eligible for eviction.

vs Least Recently Used (`lru`) vs Least Frequently Used (`lfu`)

lru means that when the memory limit is reached, the last accessed items will be deleted. lfu will try to track the frequency of access of items, so that items that are used rarely are evicted while the ones used often have an higher chance of remaining in memory.

Unsure of Which Eviction Policy to Use?

The recommended eviction policy is allkeys-lru. This is an official recommendation by Redis.

Table of all Redis Eviction Policies

Policy	Description
noeviction (default)	Returns an error if the memory limit has been reached when trying to insert more data
allkeys-lru (recommended if unsure)	Evicts the least recently used keys out of all keys
allkeys-lfu	Evicts the least frequently used keys out of all keys
allkeys-random	Randomly evicts keys out of all keys
volatile-lru	Evicts the least recently used keys out of all keys with an “expire” field set
volatile-lfu	Evicts the least frequently used keys out of all keys with an “expire” field set
volatile-random	Randomly evicts keys with an “expire” field set
volatile-ttl	Evicts the shortest time-to-live keys out of all keys with an “expire” field set.

Conclusion

There are a lot more reasons and uses cases for Redis than what I covered. However, I hope this provides an overview of some of what Redis offers and how you can start using it. Remember if data volatility is acceptable in your use case, you should use allkeys-lru. Do you currently use Redis? Let me know your thoughts down below.

If you like what you've read, want to continue the discussion, or have anything else on your mind, reach out to me on Twitter.

Cloud Native Computing Foundation Graduated Projects

Victor Darkes — Mon, 26 Oct 2020 16:01:50 +0000

Cloud Native

Cloud native technologies empower organizations to build and run scalable applications in modern environments. Containers, service meshes, microservices, immutable infrastructure, and declarative APIs are examples. Cloud native software enables loosely coupled systems that are resilient, manageable, and observable.

Cloud Native Computing Foundation

The CNCF seeks to drive adoption of cloud native software by fostering and sustaining an ecosystem of open source, vendor-neutral projects. CNCF is part of the nonprofit Linux Foundation and members include AWS, Apple, Google Cloud, and Microsoft Azure.

Why Care about CNCF?

Now more than ever, companies that are not labeled as software companies are realizing that they need to have their own proprietary software to compete in the digital age. Adopting cloud native technologies and practices enables companies to create software in-house. CNCF technologies enable cloud portability without vendor lock-in. Also the biggest companies develop, support and promote these technologies from their inception so you'll probably work with at least one of these eventually if you already haven't.

When a Project Graduates

A CNCF project can have a maturity level of sandbox, incubating, or graduated. The maturity level is a signal by CNCF as to what sorts of enterprises should be adopting different projects. Projects increase their maturity by demonstrating their sustainability to CNCF’s Technical Oversight Committee. Graduate projects are widely adopted, have frequent changes, and have a variety of contributors.

Graduated Projects

containerd - Container Runtime

containerd is a container runtime with an emphasis on simplicity, robustness and portability. It is available as a daemon, which can manage the complete container lifecycle of its host system: image transfer and storage, container execution and supervision, low-level storage and network attachments, etc. containerd is designed to be embedded into a larger system, rather than being used directly by developers or end-users.

CoreDNS - Service Discovery

CoreDNS is a Domain Name System (DNS) server and forwarder, that chains plugins. Each plugin performs a DNS function. CoreDNS is a fast and flexible DNS server that allows you to do what you want with your DNS data by utilizing plugins.

Envoy - Network Proxy

Envoy is an edge and service proxy designed for cloud native applications made by Lyft.

Fluentd - Logging

Fluentd collects events from various data sources and writes them to files, RDBMS, NoSQL, IaaS, SaaS, Hadoop and so on. Fluentd helps you unify your logging infrastructure.

Harbor - Registry

An open source registry that secures artifacts with policies and role-based access control, ensures images are scanned and free from vulnerabilities, and signs images as trusted.

Helm - Package Management

Helm is a package manager for Kubernetes that streamlines installing and managing Kubernetes applications. Helm manages Charts, which are packages of pre-configured Kubernetes resources.

Jaeger - Distributed Tracing

Jaeger is a distributed tracing platform that can be used for monitoring microservices-based distributed systems. It was created by Uber Technologies.

Kubernetes - Orchestration

Kubernetes is an open source system for managing containerized applications across multiple hosts. It provides basic mechanisms for deployment, maintenance, and scaling of applications.

Prometheus - Monitoring

Prometheus is a systems and service monitoring system. It collects metrics from configured targets at given intervals, evaluates rule expressions, displays the results, and can trigger alerts if some condition is observed to be true.

Rook - Storage

Rook is an open source cloud-native storage orchestrator for Kubernetes, providing the platform, framework, and support for a diverse set of storage solutions to natively integrate with cloud-native environments. Rook turns storage software into self-managing, self-scaling, and self-healing storage services.

TiKV - Key/Value Store

TiKV is an open-source, distributed, and transactional key-value database. Unlike other traditional NoSQL systems, TiKV not only provides classical key-value APIs, but also transactional APIs with ACID compliance.

TUF - Software Update Spec

The Update Framework (TUF) helps developers maintain the security of software update systems. TUF provides a flexible framework and specification that developers can adopt to secure any software update system.

Vitess - Storage

Vitess is a database clustering system for horizontal scaling of MySQL through generalized sharding. By encapsulating shard-routing logic, Vitess allows application code and database queries to remain agnostic to the distribution of data onto multiple shards.

Conclusion

There are a lot of different projects that all have different applications. You don't need to know or use all of these. However, if you are in a situation that requires one of these types of solutions you should consider using one of these products. Do you use any of these products already? If yes, which ones?

If you like what you've read, want to continue the discussion, or have anything else on your mind, reach out to me on Twitter.

The 5 Most Popular AWS Products

Victor Darkes — Wed, 21 Oct 2020 16:01:05 +0000

AWS Leads the Cloud Infrastructure Market

Amazon Web Services (AWS) has been the leading cloud infrastructure provider. As of 2020, AWS had a market share equal to the next three cloud providers combined (Azure, Google Cloud, Alibaba Cloud). AWS has products for every category and there are some that are more widely used than others. With over 175 services, navigating AWS can be overwhelming as a beginner. To help simplify the search of which ones to learn first. Here are the most popular AWS products.

Why are These the Most Popular?

AWS and 2nd Watch partnered to determine the most popular AWS products. AWS used data from 2nd Watch clients to create this list. This is the most recently compiled data by the two companies. These 5 are in no particular order, because they were all used by 100% of the companies surveyed. I've linked tutorials to learn more and try them out for yourself.

DynamoDB

Amazon's very own key-value and document NoSQL database. You'll have automatic storage scaling, low-latency data access, and guaranteed throughput. You should use DynamoDB if you won't plan to make a lot relational queries across multiple tables.

Simple Storage Service (S3)

An object storage service. It's advantage over DynamoDB is that it's more suited for storing images and documents. Practical use cases for S3 include: data lakes, website hosting, backup and restore, and big data analytics. Be mindful of the access policies you configure. This prevents making private business data accidentally public.

Simple Notification Service (SNS)

A fully-managed publish-and-subscribe messaging service. With SNS you can perform system-to-system and app-to-person communication. Ideal if you plan to have an event-driven architecture.

Elastic Compute Cloud (EC2)

Virtual servers managed by Amazon. Very easy to get started with by choosing one of the many Amazon Machine Images (AMI). Great for hosting your applications.

AWS Key Management Service (KMS)

Helpful for anyone interested in protecting data stored in AWS. KMS makes it easy for you to create, manage and control cryptographic keys across AWS services. Securing data is very important and stricter regulation around data will only continue to grow as time goes on. This isn't one of the more exciting AWS services. Chances are that developers at a larger company developers won't directly interact or be aware of this product. Site Reliability Engineers (SREs) / Security Operations (SecOps) would be more likely to manage keys.

Tutorial

Conclusion

If you're new to coding and managed cloud services, these are the ones to start getting yourself familiar with AWS. If you're an experienced developer, do you feel like there's any others that are more ubiquitous than these? Is your favorite product missing? Let me know in the comments.

If you like what you've read, want to continue the discussion, or have anything else on your mind, reach out to me on Twitter.

Using Gradle's Kotlin DSL to Bundle React With a Spring Boot Web Application

Victor Darkes — Sun, 26 Apr 2020 14:57:48 +0000

Putting Together a Full-Stack Codebase

I was recently looking for a way to serve a React application in a Spring Boot microservice and have the two together in a single, unified, and manageable codebase. If you're working for a large company, then it's usually best to keep the two separate. However, this is just for my personal projects and one repository to keep track of helps with velocity.

An Overview

For those unfamiliar with the Spring Framework, it is a collection of different projects that make application development easier for Java and Kotlin developers. Spring Boot is a microservice starter and is one of those projects. Simply put, the build.gradle.kts in a Spring application is the equivalent of the package.json in a React project, as it has your dependencies and tasks (which are the same as scripts).

Not too long ago, Groovy was the domain-specific language (DSL) for the Gradle build file. I have seen various articles about achieving what I want to accomplish with Groovy, but I didn't see an examples using Kotlin, which has now become the default DSL.

A domain-specific language is a computer language specialized to a particular application domain. The build file in a Spring project is the application domain.

Spring Into Action

The Spring Initialzr can help you create an project and the only dependency you need is the Spring Web starter.

The generated Spring Boot project structure will look like this:



├── gradle
│   └── wrapper
└── src
    ├── main
    │   ├── kotlin
    │   │   └── me
    │   │       └── darkes
    │   │           └── springbootreactgradlekotlin
    │   ├── resources
    └── test
        └── kotlin
            └── me
                └── darkes
                    └── springbootreactgradlekotlin

Creating the React Application

Run the following command inside the /src/main/ directory of your Spring Boot project.


 create-react-app webapp --use-npm

This will go ahead and make a new directory called /webapp with your newly made React application.

Setting Up the Gradle Build File

The whole process of having a combined codebase is possible because of the Gradle plugin, Gradle Node Plugin.

In a Spring application the resources/ directory is where we'd put our generated React build/ files, because that is where a Spring application looks for static files to serve.

Add all of this to your build.gradle.kts file in your Spring Boot application root directory.




plugins {
    id("com.github.node-gradle.node") version "2.2.2"
}

tasks.register<NpmTask>("appNpmInstall") {
    description = "Installs all dependencies from package.json"
    workingDir = file("${project.projectDir}/src/main/webapp")
    args = listOf("install")
}

tasks.register<NpmTask>("appNpmBuild") {
    dependsOn("appNpmInstall")
    description = "Builds project"
    workingDir = file("${project.projectDir}/src/main/webapp")
    args = listOf("run", "build")
}

tasks.register<Copy>("copyWebApp") {
    dependsOn("appNpmBuild")
    description = "Copies built project to where it will be served"
    from("src/main/webapp/build")
    into("build/resources/main/static/.")
}

node {
    download = true
    version = "12.13.1"
    npmVersion = "6.12.1"
    // Set the work directory for unpacking node
    workDir = file("${project.buildDir}/nodejs")
    // Set the work directory for NPM
    npmWorkDir = file("${project.buildDir}/npm")
}

tasks.withType<KotlinCompile> {
    // So that all the tasks run with ./gradlew build
    dependsOn("copyWebApp")
    kotlinOptions {
        freeCompilerArgs = listOf("-Xjsr305=strict")
        jvmTarget = "1.8"
    }
}

Building the Project

All you have to do is run ./gradlew build from your project root directory. You'll notice after Gradle is finished, the React build directory is in the new location build/resources/main/static/.

If you want to see the application in action you can run java -jar build/libs/PROJECT_NAME.jar from the project root directory. Then visit localhost:8080.

How It All Works

Typically with a normal React application you'll use npm install and npm run build. The Gradle plugin provides NpmTask to run those same commands. The tasks that I included are all that's needed to install, build and copy the files to where the Spring Boot application will notice them. Additionally, if you're someone who prefers Yarn or just wants to run a Node.js script, you can use this plugin to do that too!

The code can be found here:

iamdarkes / spring-boot-react-gradle-kotlin-dsl

Using Gradle's Kotlin DSL to Bundle React With a Spring Boot Web Application

Using Gradle's Kotlin DSL to Bundle React with a Spring Boot Web Application

This project contains an example of how to serve a React application from Spring Boot using Gradle's Kotlin DSL.

Read the Article

How to Connect & Support

View on GitHub

I hope this was helpful. If you're used to using another language or technology for your server-side code, this starter is a great way to give Kotlin and Spring Boot a try.

DEV Community: Victor Darkes

Popular Kotlin Server-Side Libraries

Kotlin for the Win

Web

Testing

Documentation

Dependency Injection

Database

Miscellaneous

Conclusion

Infrastructure as Code Explained

What is Infrastructure?

Why Manage Infrastructure With Code?

List of Popular Tools

The Difference

Conclusion

All Redis Eviction Policies Cheatsheet & Explanation

What is Redis?

Why use Redis?

In-Memory vs On-Disk

What's an Eviction Policy

The Default Eviction Policy

allkeys vs volatile

vs Least Recently Used (lru) vs Least Frequently Used (lfu)

Unsure of Which Eviction Policy to Use?

Table of all Redis Eviction Policies

Conclusion

Cloud Native Computing Foundation Graduated Projects

Cloud Native

Cloud Native Computing Foundation

Why Care about CNCF?

When a Project Graduates

Graduated Projects

Conclusion

The 5 Most Popular AWS Products

AWS Leads the Cloud Infrastructure Market

Why are These the Most Popular?

Conclusion

Using Gradle's Kotlin DSL to Bundle React With a Spring Boot Web Application

Putting Together a Full-Stack Codebase

An Overview

Spring Into Action

Creating the React Application

Setting Up the Gradle Build File

Building the Project

How It All Works

iamdarkes / spring-boot-react-gradle-kotlin-dsl

Using Gradle's Kotlin DSL to Bundle React With a Spring Boot Web Application

Using Gradle's Kotlin DSL to Bundle React with a Spring Boot Web Application

Read the Article

How to Connect & Support

`allkeys` vs `volatile`

vs Least Recently Used (`lru`) vs Least Frequently Used (`lfu`)