Forem: Habeeb Okunade

Tips to pass the CNCF Certified Kubernetes Application Developer (CKAD) exam

Habeeb Okunade — Thu, 30 Jul 2020 06:00:51 +0000

Short Intro …

The Certified Kubernetes Application Developer (CKAD) program has been developed by the Cloud Native Computing Foundation (CNCF), in collaboration with The Linux Foundation, to help expand the Kubernetes ecosystem through standardized training and certification.

The exam is proctored online. It is a performance-based test which consists of a set of performance-based items (19 problems) to be solved in a command line within two (2) hours.

The cost is $US 300 and includes one free retake. This exam curriculum includes these general domains and their weights on the exam are:

13% — Core Concepts (pods, resources, quotas, kubectl — run, get, delete, create etc.)
18% — Configuration (ConfigMaps, Secrets, ServiceAccounts, SecurityContexts)
10% — Multi-Container Pods (SideCars, Ambassadors, Adapters)
18% — Observability (Logging, Monitoring, Debugging, Events, Probes)
20% — Pod Design (Deployments, ReplicaSets, Jobs, CronJobs, Update & Rollback Strategies, Taints, Tolerations, Affinity)
13% — Services & Networking (Services — ClusterIP, NodePort — Ingress Resources, Network Policies — Ingress, Egress)
8% — State Persistence (Volumes, Mounts, PersistenceVolumes, PersistenceVolumeClaims)

You can learn more about this certification at the official page of CNCF at CKAD at cncf.io

How to practice/prepare for the exam

There are a lot of resources out there that you can use to prepare and practice for the CKAD exam and the best I can recommend are listed below:

Official Kubernetes Documentation (https://kubernetes.io/docs/home/) — familiarise yourself with this page, know how to navigate between the tasks and the concepts and master the sidebar menu as this will be the only page you can reference during the exam.
Use https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands on the page to master kubectl commands
Courses — Udemy, edX, Udacity, KodeKloud
You can master Kubernetes by subscribing to video courses especially that of Mumshad Mannambeth at KodeKloud (https://kodekloud.com/courses). Here you can learn and practice Kubernetes with hands-on questions that include Mocks, Projects, Labs etc. Also, you can register for the free edX course by the Linux Foundation at https://www.edx.org/course/introduction-to-kubernetes
Books — Kubernetes: Up and Running, Kubernetes in Action, The Kubernetes Book. These are some of the books you can lay your hands on to master Kubernetes.
Unofficial Kubernetes — https://unofficial-kubernetes.readthedocs.io/
I really love this page. It explains so many concepts of Kubernetes. You can delve into it as well. (Note: It is unofficial page)
Kubernetes Cheat Sheet — Cheat Sheet
Please download and print out this two pages sheet. Paste it on your wall to quickly make reference to it.
Short Tutorials and Tips
Once you have mastered K8s and you are prepared to take the exam, you can practice some tutorials and write-ups from these pages:
a. https://github.com/dgkanatsios/CKAD-exercises
b. https://github.com/twajr/ckad-prep-notes
c. https://www.reddit.com/r/kubernetes/comments/9uydc1/passed_the_ckad_special_thanks_to_the_linux/
d. https://medium.com/devopslinks/my-story-towards-cka-ckad-and-some-tips-daf495e711a9
e. https://medium.com/chotot-techblog/tips-tricks-to-pass-certified-kubernetes-application-developer-ckad-exam-67c9e1b32e6e
fluentd — Practice this task and master it
https://kubernetes.io/docs/concepts/cluster-administration/logging/#sidecar-container-with-a-logging-agent

Tips & tricks during the exam

The duration of the exam is 120 minutes with 19 problems to tackle, approximately 6.3 minutes/problem. The following tips will help you to take good advantage of the time during the exam:

Don’t spend too much time on one question. Skip the questions with weight 2%-3% if it takes a long time. Note it on the provided notepad and reattempt them when you have time.
IMPORTANT: Always copy and run the context command provided at the top of each question. Before you attempt any question, use your mouse to copy the command provided at the top of the question and run it on the console in order to be on the right context. Although most questions will have the same context, some need to be done in another context; in order to be safe, run the command at the top of a question before attempting the question.
Shorthands — Use shorthand for some applicable resources.

#To get all the kubernetes resources shorthands, run
$ kubectl api-resources

#Then use shorthand to create those resources
$ kubectl create deploy nginx --image nginx #Deployments
$ kubectl create cm app-config --from-literal var2=val2 

#ConfigMaps
$ kubectl get sa #ServiceAccounts
$ kubectl get rs #ReplicaSets

ALIASES are Time Savers

Use an alias for some common command at the start of the exam before you begin providing solutions to the questions. The following 6 commands will help you to save almost 10 minutes (Save more in conjunction with shorthand):

$ alias k='kubectl'
$ alias kg='kubectl get'
$ alias kd='kubectl delete'
$ alias kr='kubectl run'
$ alias kc='kubectl create'
$ alias kcf='kubectl create -f'

#Examples of using them in your exam.
#Create resources from a YAML file
$ kcf pod.yaml

#Get pods resources
$ kg po
$ kg deploy
$ kg rs

#Create resources
$ kc cm pod-config --from-literal var4=val4
$ kc deploy busybox --image busybox -it -- /bin/sh -c 'echo Hello'

Create a resource file from kubectl command using the dry-run and -o yaml instead of writing the complete spec for the file.

#Create a resource YAML file
$ kr nginx --image nginx -oyaml --dry-run=client -- env > pod1.yaml
$ vi pod1.yaml #To edit the file
$ kc deploy nginx --image nginx -oyaml --dry-run=client > nginx.yaml
$ vi nginx.yaml #To add some contents like replicas etc

NAMESPACES — Take notice of any namespace mentioned in any question. If no namespace is provided, it is assumed to work in the default namespace.

If you encounter any question with namespace, read it till the end to know if the namespace has been created for you, if not, then you have to create it.

You might be asked to identify a particular resource that has an issue, it is important to know that the resource might belong to another namespace. So use get all with all namespaces to find out.

#Get namespaces
$ kg ns

#Create a namespace
$ kc ns dev-space

#Get all the resources in all the namespaces
$ k get po -A  #kubectl get pods --all-namespaces

#Create a pod in dev-space namespace
#Check if the namespace exists by using 'kg ns', if not, create it
$ kr nginx --image nginx --labels app=backend -n dev-space

#Get pods in a particular namespace
$ kg po -n dev-space

These are the tips for you to ace the K8s CKAD exam. Practice using the tips provided above and if it comes out otherwise, you can attempt it a second time for free.

I wish you good luck with your exam.

Spring @ConfigurationProperties annotation explained

Habeeb Okunade — Sun, 01 Mar 2020 10:37:35 +0000

Spring @ConfigurationProperties. Spring provides several ways of… | by Habeeb Okunade | Medium

Habeeb Okunade ・ Mar 1, 2020 ・ 10 min read
Medium

Spring provides several ways of injecting/looking up values from the application configuration properties file.

One of them is the @Value annotation discussed in the Spring @Value annotation tricks write up.

Another one is the using @ConfigurationProperties annotation on a configuration bean to inject properties values to a bean and use it in the class. Also is the using of Environment object to lookup values, properties or profiles in the classpath.

In this write-up, I will demonstrate how to use @ConfigurationProperties annotation to inject properties values from the application.properties or application.yaml files.

Let go to https://start.spring.io/ to generate and bootstrap our project.
Choose Maven Project, Java as the language, give your project the group name and artefact Id. Select Spring Web as the only dependency for our project.

Click ‘Generate’ button to download the bootstrapped project as a zip file. Unzip the file and open it with your prefered IDE as a Maven project to download all the required dependencies and at the end of all these, your project structure should look like the image below:

Open the application.properties file and write the properties values below:

#DEV environment properties
dev.name=Development Application
dev.port=8091
dev.dbtype=Maria DB
dev.version=1.0.alpha
dev.dburl=jdbc:mariadb://localhost:3306/
dev.dbname=studentDB
dev.dbuser=root
dev.dbpassword=root

#QA environment properties
qa.name=QA Test Application
qa.port=8092
qa.dbtype=Mongo DB
qa.version=1.2.beta
qa.dburl=mongodb://mongodb0.example.com:27017/
qa.dbname=studentDB
qa.dbuser=admin
qa.dbpassword=admin

#PROD environment properties
prod.name=Production Application
prod.port=8091
prod.dbtype=MySQL
prod.version=1.0.1
prod.dburl=jdbc:mysql://localhost:3308/
prod.dbname=studentDB
prod.dbuser=admin-prod
prod.dbpassword=admin-prod

The file contains three properties values for three different environment — dev, qa and prod. Each property is prefixed with the type of environment they belong to. This is not a good practice to have all these specific environment properties on a single file. In reality, we cannot have different environment properties like this, but rather create a specific application properties file for each environment, set up a profile and choose the active profile or profiles to use. Just bear with me with this approach to show how to use the annotation. Our aim is to load these properties into our application by creating beans and using @ConfigurationProperties annotation.

Let’s create a package called config and create three classes DevConfigProps.java, QaConfigProps.java and ProdConfigProps.java in this package and annotate each class with @Configuration to tell spring that these classes should be scanned, managed and configured as spring beans during application bootup.

If you consider the application.properties file above, you will notice that each of these properties is either prefix with dev, qa or prod. These prefixes will be used to configure these classes by using the @ConfigurationProperties("prefix") annotation.

@ConfigurationProperties("dev") for dev properties, @ConfigurationProperties("qa") for qa properties and @ConfigurationProperties("prod") for prod properties.

//DevConfigProps.java
package com.habeebcycle.configurationpropertiesannotation.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties("dev")
public class DevConfigProps {

}


//QaConfigProps.java

package com.habeebcycle.configurationpropertiesannotation.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties("qa")
public class QaConfigProps {

}


//ProdConfigProps.java

package com.habeebcycle.configurationpropertiesannotation.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties("prod")
public class ProdConfigProps {

}

@ConfigurationProperties allows us to map the entire properties or YAML files into an object easily. It also allows us to validate properties with JSR-303 bean validation. By default, the annotation reads from the application.properties file. The properties file to be used can be changed with @PropertySource("file-name") annotation if we don’t want to use the default properties file.

The next step is to create all the properties names as a variable with their setters and getters.

for DevConfigProps.java

package com.habeebcycle.configurationpropertiesannotation.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties("dev")
public class DevConfigProps {

    private String name;
    private int port;
    private String dbType;
    private String version;
    private String dbUrl;
    private String dbName;
    private String dbUser;
    private String dbPassword;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getDbType() {
        return dbType;
    }

    public void setDbType(String dbType) {
        this.dbType = dbType;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getDbUrl() {
        return dbUrl;
    }

    public void setDbUrl(String dbUrl) {
        this.dbUrl = dbUrl;
    }

    public String getDbName() {
        return dbName;
    }

    public void setDbName(String dbName) {
        this.dbName = dbName;
    }

    public String getDbUser() {
        return dbUser;
    }

    public void setDbUser(String dbUser) {
        this.dbUser = dbUser;
    }

    public String getDbPassword() {
        return dbPassword;
    }

    public void setDbPassword(String dbPassword) {
        this.dbPassword = dbPassword;
    }
}

for QaConfigProps.java

package com.habeebcycle.configurationpropertiesannotation.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties("qa")
public class QaConfigProps {

    private String name;
    private int port;
    private String dbType;
    private String version;
    private String dbUrl;
    private String dbName;
    private String dbUser;
    private String dbPassword;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getDbType() {
        return dbType;
    }

    public void setDbType(String dbType) {
        this.dbType = dbType;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getDbUrl() {
        return dbUrl;
    }

    public void setDbUrl(String dbUrl) {
        this.dbUrl = dbUrl;
    }

    public String getDbName() {
        return dbName;
    }

    public void setDbName(String dbName) {
        this.dbName = dbName;
    }

    public String getDbUser() {
        return dbUser;
    }

    public void setDbUser(String dbUser) {
        this.dbUser = dbUser;
    }

    public String getDbPassword() {
        return dbPassword;
    }

    public void setDbPassword(String dbPassword) {
        this.dbPassword = dbPassword;
    }
}

for ProdConfigProps.java

package com.habeebcycle.configurationpropertiesannotation.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties("prod")
public class ProdConfigProps {

    private String name;
    private int port;
    private String dbType;
    private String version;
    private String dbUrl;
    private String dbName;
    private String dbUser;
    private String dbPassword;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getDbType() {
        return dbType;
    }

    public void setDbType(String dbType) {
        this.dbType = dbType;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getDbUrl() {
        return dbUrl;
    }

    public void setDbUrl(String dbUrl) {
        this.dbUrl = dbUrl;
    }

    public String getDbName() {
        return dbName;
    }

    public void setDbName(String dbName) {
        this.dbName = dbName;
    }

    public String getDbUser() {
        return dbUser;
    }

    public void setDbUser(String dbUser) {
        this.dbUser = dbUser;
    }

    public String getDbPassword() {
        return dbPassword;
    }

    public void setDbPassword(String dbPassword) {
        this.dbPassword = dbPassword;
    }
}

To test our properties, let’s create a configuration class that implements CommandLineRunner so that we can log all the properties configured in its run method. In this class, we will have these three configuration classes autowired since they are spring managed beans.

package com.habeebcycle.configurationpropertiesannotation;

import com.habeebcycle.configurationpropertiesannotation.config.DevConfigProps;
import com.habeebcycle.configurationpropertiesannotation.config.ProdConfigProps;
import com.habeebcycle.configurationpropertiesannotation.config.QaConfigProps;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Configuration;

@Configuration
public class PropertiesConfig implements CommandLineRunner {

    private final DevConfigProps devConfigProps;
    private final QaConfigProps qaConfigProps;
    private final ProdConfigProps prodConfigProps;

    private static final Logger logger = LoggerFactory.getLogger(
          ConfigurationPropertiesAnnotationApplication.class);

    @Autowired
    public PropertiesConfig(DevConfigProps devConfigProps, 
          QaConfigProps qaConfigProps, ProdConfigProps prodConfigProps) {

        this.devConfigProps = devConfigProps;
        this.qaConfigProps = qaConfigProps;
        this.prodConfigProps = prodConfigProps;
    }


    @Override
    public void run(String... args) throws Exception {
        logger.info("-------------Dev Properties-----------------");
        logger.info("Name: {}", devConfigProps.getName());
        logger.info("Port: {}", devConfigProps.getPort());
        logger.info("DB Type: {}", devConfigProps.getDbType());
        logger.info("Version: {}", devConfigProps.getVersion());
        logger.info("DB Url: {}", devConfigProps.getDbUrl());
        logger.info("DB name: {}", devConfigProps.getDbName());
        logger.info("DB User: {}", devConfigProps.getDbUser());
        logger.info("DB Password: {}", devConfigProps.getDbPassword());

        logger.info("-------------QA Properties-----------------");
        logger.info("Name: {}", qaConfigProps.getName());
        logger.info("Port: {}", qaConfigProps.getPort());
        logger.info("DB Type: {}", qaConfigProps.getDbType());
        logger.info("Version: {}", qaConfigProps.getVersion());
        logger.info("DB Url: {}", qaConfigProps.getDbUrl());
        logger.info("DB name: {}", qaConfigProps.getDbName());
        logger.info("DB User: {}", qaConfigProps.getDbUser());
        logger.info("DB Password: {}", qaConfigProps.getDbPassword());

        logger.info("-------------Prod Properties---------------");
        logger.info("Name: {}", prodConfigProps.getName());
        logger.info("Port: {}", prodConfigProps.getPort());
        logger.info("DB Type: {}", prodConfigProps.getDbType());
        logger.info("Version: {}", prodConfigProps.getVersion());
        logger.info("DB Url: {}", prodConfigProps.getDbUrl());
        logger.info("DB name: {}", prodConfigProps.getDbName());
        logger.info("DB User: {}", prodConfigProps.getDbUser());
        logger.info("DB Password: {}", prodConfigProps.getDbPassword());
    }
}

Running the application as a SpringBoot application will log the following into the console:

---------------------Dev Properties-------------------------
2020-03-01 17:26:25.625 [main]: Name: Development Application
2020-03-01 17:26:25.626 [main]: Port: 8091
2020-03-01 17:26:25.626 [main]: DB Type: Maria DB
2020-03-01 17:26:25.626 [main]: Version: 1.0.alpha
2020-03-01 17:26:25.626 [main]: DB Url: jdbc:mariadb://localhost:3306/
2020-03-01 17:26:25.626 [main]: DB name: studentDB
2020-03-01 17:26:25.626 [main]: DB User: root
2020-03-01 17:26:25.627 [main]: DB Password: root
---------------------QA Properties-------------------------
2020-03-01 17:26:25.627 [main]: Name: QA Test Application
2020-03-01 17:26:25.627 [main]: Port: 8092
2020-03-01 17:26:25.627 [main]: DB Type: Mongo DB
2020-03-01 17:26:25.627 [main]: Version: 1.2.beta
2020-03-01 17:26:25.627 [main]: DB Url: mongodb://mongodb0.example.com:27017/
2020-03-01 17:26:25.627 [main]: DB name: studentDB
2020-03-01 17:26:25.627 [main]: DB User: admin
2020-03-01 17:26:25.627 [main]: DB Password: admin
---------------------Prod Properties-------------------------
2020-03-01 17:26:25.627 [main]: Name: Production Application
2020-03-01 17:26:25.627 [main]: Port: 8091
2020-03-01 17:26:25.627 [main]: DB Type: MySQL
2020-03-01 17:26:25.628 [main]: Version: 1.0.1
2020-03-01 17:26:25.628 [main]: DB Url: jdbc:mysql://localhost:3308/
2020-03-01 17:26:25.628 [main]: DB name: studentDB
2020-03-01 17:26:25.628 [main]: DB User: admin-prod
2020-03-01 17:26:25.628 [main]: DB Password: admin-prod

Using `@ConfigurationProperties` to inject List properties.

We can also use @ConfigurationProperties to read List values from a properties file.

#application.properties

dev.mylist=SUN,MON,TUE,WED,THU,FRI,SAT

and use @ConfigurationProperties to inject the list as follows

package com.habeebcycle.configurationpropertiesannotation.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import java.util.List;

@Configuration
@ConfigurationProperties("dev")
public class DevConfigProps {
   private List<String> myList;

   public List<String> getMyList() {
      return myList;
   }

   public void setMyList(List<String> myList) {
      this.myList = myList;
   }

}

Logging the property gives

[SUN, MON, TUE, WED, THU, FRI, SAT]

Using `@ConfigurationProperties` to inject Map (key-value pairs) properties

key-value pair properties can be read or injected with @ConfigurationProperties annotation as follows:

#application.properties

dev.db.url=jdbc:mysql://localhost:3308/
dev.db.name=student_marks
dev.db.user=root
dev.db.password=root

From the properties file above, we can see that after the prefix dev, we have db. This db will be the variable to use to inject the values as a key-value map.

package com.habeebcycle.configurationpropertiesannotation.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import java.util.Map;

@Configuration
@ConfigurationProperties("dev")
public class DevConfigProps {
private Map<String, String> db;

   public Map<String, String> getDb() {
      return db;
   }

   public void setDb(Map<String, String> db) {
      this.db = db;
   }

}

Spring will automatically inject the nested properties into the db variables as Map variable.

Logging out the property value of devConfigProps.getDb(), will output the following:

{
   "url": "jdbc:mysql://localhost:3308/",
   "name": "student_marks",
   "user": "root",
   "password": "root"
}

Using `@ConfigurationProperties` to inject a class (Object) from a properties file

Let’s create a class called Student.java

package com.habeebcycle.configurationpropertiesannotation.model;

public class Student {

    private String id;
    private String name;
    private int age;
    private String level;
    private double mark;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }

    public double getMark() {
        return mark;
    }

    public void setMark(double mark) {
        this.mark = mark;
    }
}

If we have a properties file as follows

#application.properties

dev.student.id=ABC123XYZ
dev.student.name=Habeeb Okunade
dev.student.age=34
dev.student.level=700J
dev.student.mark=99.4

From the properties file above, we can see that after the prefix dev, we have student*. This student will be the variable to use to inject the values as a Student* object.

package com.habeebcycle.configurationpropertiesannotation.config;

import com.habeebcycle.configurationpropertiesannotation.model.Student;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;


@Configuration
@ConfigurationProperties("dev")
public class DevConfigProps {

    private Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

}

Spring will automatically inject the nested properties into the student object as Student variable.

Logging out the property value of devConfigProps.getStudent(), will output the following:

{
   "id": "ABC123XYZ",
   "name": "Habeeb Okunade",
   "age": 34,
   "level": "700J",
   "mark": 99.4
}

Using `@ConfigurationProperties` on a `@Bean` method

We can also use @ConfigurationProperties annotation on @Bean-annotated methods.

This approach may be particularly useful when we want to bind properties to a third-party component that’s outside of our control.

Let’s create a simple School class to show how to use this:

package com.habeebcycle.configurationpropertiesannotation.model;

public class School{

    private String id;
    private String name;
    private int size;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

}

Now, let’s see how we can use @ConfigurationProperties on a @Bean method to bind externalized properties to the School instance:

package com.habeebcycle.configurationpropertiesannotation.config;

@Configuration
public class ExternalConfigProperties {

    @Bean
    @ConfigurationProperties("school")
    public School school() {
        return new School();
    }
}

By this, any school-prefixed property will be mapped to the **School instance managed by the Spring context.

Using `@ConfigurationProperties` for property validation

@ConfigurationProperties provides validation of properties using the JSR-303 format. This allows our properties to come out neatly. Consider the following class:

package com.habeebcycle.configurationpropertiesannotation.config;

import org.hibernate.validator.constraints.Length;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;

@Configuration
@ConfigurationProperties("validate")  
@Validated
public class ConfigValidation {

    @NotNull
    private String dbUrl;

    @Length(min = 4, max = 10)
    private String dbUser;

    @Min(8080)
    @Max(8100)
    private int dbPort;

    @Pattern(regexp = "^[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,6}$")
    private String adminEmail;

    public String getDbUrl() {
        return dbUrl;
    }

    public void setDbUrl(String dbUrl) {
        this.dbUrl = dbUrl;
    }

    public String getDbUser() {
        return dbUser;
    }

    public void setDbUser(String dbUser) {
        this.dbUser = dbUser;
    }

    public int getDbPort() {
        return dbPort;
    }

    public void setDbPort(int dbPort) {
        this.dbPort = dbPort;
    }

    public String getAdminEmail() {
        return adminEmail;
    }

    public void setAdminEmail(String adminEmail) {
        this.adminEmail = adminEmail;
    }
}

This class has some validation rules for the @ConfigurationProperties annotation to work.

The @NotNull annotation tells the Spring that the dbUrl field is mandatory and throws an error if not found.

The @Length(min=4, max=6) annotation validate dbUser to only inject property of a minimum of 4 characters and 6 characters long.

The @Min and @Max annotation to inject port value in the range of 8080 to 8100.

lastly, the adminEmail property must match the pattern provided as @Pattern(regexp = "^[a-z0–9._%+-]+@[a-z0–9.-]+\.[a-z]{2,6}$")

This helps us reduce a lot of if-else conditions in our code and makes it look much cleaner and concise.

If any of these validations fail, then the main application would fail to start with an IllegalStateException.

In this write-up, I have shown how to use @ConfigurationProperties to read /inject configuration properties from a properties file and explained some of the handy features it provides like property mapping, binding and validation.

Spring @Value annotation tricks

Habeeb Okunade — Sun, 01 Mar 2020 01:39:20 +0000

Spring @Value annotation tricks. Spring framework provides@Value… | by Habeeb Okunade | Medium

Habeeb Okunade ・ Feb 29, 2020 ・
Medium

Spring framework provides @Value annotation in the org.springframework.beans.factory.annotation package. This annotation is used at various level in our application either at field level for expression-driven dependency injection in which a value can be injected into a variable in a class or at the parameter level of a method or a constructor that indicates a default value expression for the main argument. It is also used for dynamic resolution of handler method parameters like in Spring MVC.

@Value annotation can be used within classes annotated with @Configuration , @Component and other stereotype annotations like @Controller , @Service etc. The actual processing of @Value annotation is performed by BeanPostProcessor and so @Value cannot be used within BeanPostProcessor class types.

@Value annotation uses property placeholder syntax ${...} and Spring Expression Language, SpEL, syntax #{$...} to formulate expressions. ${...} is a property placeholder syntax while #{$...} is a SpEL syntax. #{$...} syntax can also handle property placeholders and a lot more.

In this write-up, I will discuss some tricks in using @Value annotation in a sample Spring Boot application. Let go to https://start.spring.io/ to generate and bootstrap our project.

Choose Maven Project, Java as the language, give your project the group name and artefact Id. Select Spring Web as the only dependency for our project.

Click ‘Generate’ button to download the bootstrapped project as a zip file. Unzip the file and open it with your prefered IDE as a Maven project to download all the required dependencies.

Create a new package, name it ‘controller’ and create a new class called ValueController.java. Make sure to have the following in it

Here, I have annotated the class with @RestController a child of stereotype Controller so that the value annotation can inject and work properly.

1. @Value Placeholder Syntax `@Value("")`



package com.habeebcycle.springvalueannotation.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ValueController {

    @Value("Hello World")
    private String greetingMessage;

    @GetMapping("")
    public String sendGreeting(){
        return greetingMessage;
    }
}

The value annotation is used to hold the value for the variable greetingMessage. When the project is run and the endpoint http://localhost:8080 is hit, the word Hello World is displayed on the browser. This shows that the @Value annotation works very well with class variables to inject the default value at runtime. As it works with String data type, it also works for other primitives and wrapper types like int, double, boolean, Integer, Double and Boolean as shown below:



@Value("1.234")
private double doubleValue; //could be Double

@Value("1234")
private Integer intValue; //could be int

@Value("true")
private boolean boolValue; //could be Boolean

@Value("2000")
private long longValue;

2. @Value Property Placeholder Syntax `@Value("${...}")`

Most of the spring applications have a property file that is used to configure some values or properties in the application. SpringApplication loads properties from application.properties files in the classpath and add them to the Spring Environment. In the example above, the spring boot initializer has already bootstrapped application.properties file in the application under src/main/resource folder. Let’s create some properties and access them in the application using the @Value annotation.



#application.properties
greeting.message=Hello World!

We can use @Value("${...property's name}") annotation to access the above property in the Java class as follows:



ackage com.habeebcycle.springvalueannotation.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ValueController {

    @Value("${greeting.message}") 
    private String greetingMessage;

    @GetMapping("")
    public String sendGreeting(){
        return greetingMessage;
    }
}

Hitting the endpoint http://127.0.0.1:8080 will display the variable greetingMessage as Hello World! on the browser. The property value is injected at runtime from the property file to the variable.

If the property name is not present in the application.properties file, the application throws errors as shown below:



Error starting ApplicationContext. To display the conditions report re-run your application with 'debug' enabled.
2020-02-29 21:54:43.953 ERROR 2996 --- [           main] o.s.boot.SpringApplication               : Application run failed
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'valueController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'greeting.message' in value "${greeting.message}"

A default value can be provided to the annotation, which can be used if the property name in the @Value annotation is not present in the application.properties file. The implementation is shown below:



package com.habeebcycle.springvalueannotation.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ValueController {

    @Value("${greeting.message:Greeting not found!}")
    private String greetingMessage;

    @GetMapping("")
    public String sendGreeting(){
        return greetingMessage;
    }
}

A colon : is placed in front of the property name and the default value is provided to the annotation. This tells the annotation to use the default value provided to it if the property name is not found in the application.properties file. Caution needs to be taken when providing the default value as to where the colon : is placed. If there is a space between the property name and colon : as shown



@Value("${greeting.message :Greeting not found!}")
private String greetingMessage;

the default value provided will always be used even if the property name exists in the properties file. Therefore, space should not be inserted before the colon : as it might cause unexpected behaviour. This also applies to other primitives and wrapper types like int, double, boolean, Integer, Double and Boolean as shown below:



#application.properties

my.int.value=20
my.double.value=3.142
my.boolean.value=true

//In the Java file

@Value("${my.int.value:0}")
private int intValue; //injects 20 at runtime

@Value("${my.double.value: 0.0}")
private double doubleValue; //injects 3.142 at runtime

//This takes the default value provided despite having the property 
//name in the properties file.
@Value("${my.boolean.value :false}")
private boolean boolValue; //injects false because of space

//Property name not found in the properties file
@Value("${my.long.value:300}")
private long longValue; //injects 300 at runtime

3. @Value Property Placeholder Syntax `@Value("${...}")` with List of values

@Value("${...}") can be used to inject list values from properties file at runtime. Consider the properties file below:



#application.properties
my.weekdays=Mon,Tue,Wed,Thu,Fri

and in the Java file



@Value("${my.weekdays}")
private List<String> strList; // injects [Mon, Tue, Wed, Thu, Fri]

//Providing default value
@Value("${my.weekends:Sat,Sun,Fri}")
private List<String> strList2; // injects [Sat, Sun, Fri]

4. @Value Spring Expression Language Syntax `@Value("#{${...}}")` with Map (key-value pair)

@Value("#{${...}}") can be used to inject map (key-value) pair from properties file at runtime. The example below shows how to do this:



#application.properties
database.values={url:'http://127.0.0.1:3306/', db:'mySql', username:'root', password:'root'}

We can use SpEL as follows to inject the database.values property.



package com.habeebcycle.springvalueannotation.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class ValueController {

    @Value("#{${database.values}}")
    private Map<String, String> dbValues;

    @GetMapping("")
    public Map getDBProps(){
        return dbValues;
    }
}

Hitting endpoint http://localhost:8080 will return the following output



{
  "url": "http://127.0.0.1:3306/",
  "db": "mySql",
  "username": "root",
  "password": "root"
}

To use the default value in case the property name is not found on the properties file.



@Value("#{${database.values: {url: 'http://127.0.0.1:3308/', db: 'mySql', username: 'root', password: ''}}}")
private Map<String, String> dbValues;

When database.values property is not defined in the properties file, the default map {url:'http://127.0.0.1:3308/', db:'mySql', username:'root', password:''} will be injected to the variable dbValues at runtime.

5. @Value Construction Injection with `@Value("${...}")`

@Value can be used with constructor parameter and then in constructor injection, Spring will inject value specified by @Value annotation. Suppose we have the following properties in the properties file.



#application.properties

company.name= Scopesuite Pty ltd
#company.location= Sydney

We can use @Value annotation during construction as follows



package com.habeebcycle.springvalueannotation.service;
import org.springframework.stereotype.Service;
@Service
public class CompanyService {
   private String compName;
   private String location;

   public CompanyService(@Value("${company.name}") String compName,
    @Value("${company.location:Washington}") String location){

       this.compName = compName;
       this.location = location;
   }
   ------
}

In the above constructor, the first argument will be injected using the value from the properties file. If the property key for the second argument is not found, the default value will be injected.

Performing basic stats in Java 8

Habeeb Okunade — Sat, 22 Feb 2020 08:52:29 +0000

The Stream interface is introduced in Java 8 which supports parallel execution. The Stream interface supports the sorted, map, filter, reduce pattern and executes easily, forming the basis (along with lambdas) for functional-style programming. There are also corresponding primitive streams (IntStream, DoubleStream, and LongStream) for performance reasons.

In this write-up, we will be looking at how to perform basic statistics like maximum, minimum, mean (average) and the number of occurrences for data presentation purposes with stream API and Collections. Our approach will be to create values using one of the classes in the stream API (java.util.stream) and Collections and statistics utilities provided in the package java.util called DoubleSummaryStatistics (You can also explore IntSummaryStatistics and LongSummaryStatistics to perform basic statistics with them).

Let's assume we have a set of data, we will use of of DoubleStream (stream API) to collate, sort or filter our data, and use summaryStatistics method to get the maximum, minimum, average, count and the sum of our data.

We will use the frequency method of Collections to get the number of occurrence for value in the dataset which can be used to form the basis of presentation as a histogram.

Let's start coding to see this in action.

package com.habeebcycle;

import java.util.stream.*;
import java.util.*;

public class BasicStats{    
    public static void main (String[] args) {

                //Dataset as follows
        double dataset[] = {32, 23, 54, 15.2, 26.3, 7.1, 18.7, 14.2, 23,
                 25, 21.7, 12.4, 21, 24, 42, 55, 23, 14.5, 21.3, 26.3, 53, 23,
                 15.2, 7.1, 15.4, 23, 15.2, 14.2, 14.2, 25, 18.7, 15.2, 14.5};

        //Get the basic statistics
        DoubleSummaryStatistics stats = 
                    DoubleStream.of(dataset).summaryStatistics();

        // Now stats variable has our basic stats

        //Let's get the total values in our dataset
        System.out.println (stats.getCount()); //Gives 33;

        //Let's get the sum
        System.out.println (stats.getSum()); //Gives 753.4

        //Let's get the mean (average)
        System.out.println (stats.getAverage()); //Gives 22.83

        //Let's get the maximum
        System.out.println (stats.getMax()); //Gives 55.0

        //Let's get the maximum
        System.out.println (stats.getMin()); //Gives 7.10
    }
}

We can combine statistical results to operates on them at once by using

   stats.combine(DoubleSummaryStatistics otherStats);

To get our dataset as a presentation approach, we are going to use boxed() method of the stream, so that the collect method could work with Collectors class.

Collectors class has a method called groupingBy that can be used to group our dataset as a distinct set by counting the number of occurrence of each value in the dataset.

Map<Double, Long> histogram =
 DoubleStream.of(dataset)
  .boxed()
  .collect(Collectors.groupingBy(
       e -> e, 
       Collectors.counting()
   ));

histogram now has each data with the number of occurrence as a key-value map. We can use our custom method to print out the histogram using stars.

for(Double data : histogram.keySet()){
   System.out.println (
     data + " : " + histogram.get(data) + " : " + getStars(histogram.get(data))
   );
}

Where getStars method is defined as follows:

public static String getStars(long number){
   String output = "";
   for(int i = 1; i <= number; i++){
      output += " * ";
   }
   return output;
}

The output present our data as a histogram

32.0 : 1 :  * 
18.7 : 2 :  *  * 
15.4 : 1 :  * 
42.0 : 1 :  * 
12.4 : 1 :  * 
21.7 : 1 :  * 
15.2 : 4 :  *  *  *  * 
53.0 : 1 :  * 
14.2 : 3 :  *  *  * 
55.0 : 1 :  * 
54.0 : 1 :  * 
14.5 : 2 :  *  * 
21.0 : 1 :  * 
26.3 : 2 :  *  * 
23.0 : 5 :  *  *  *  *  * 
21.3 : 1 :  * 
24.0 : 1 :  * 
25.0 : 2 :  *  * 
7.1  : 2 :  *  *

The Stream API combined with Collections utilities are powerful with a simple set of tools for processing dataset. It allows us to reduce a huge amount of boilerplate code, create more readable programs and improve app’s productivity when used properly.

Forem: Habeeb Okunade

Tips to pass the CNCF Certified Kubernetes Application Developer (CKAD) exam

Short Intro …

How to practice/prepare for the exam

Tips & tricks during the exam

Spring @ConfigurationProperties annotation explained

Spring @ConfigurationProperties. Spring provides several ways of… | by Habeeb Okunade | Medium

Habeeb Okunade ・ Mar 1, 2020 ・ 10 min read Medium

Using @ConfigurationProperties to inject List properties.

Using @ConfigurationProperties to inject Map (key-value pairs) properties

Using @ConfigurationProperties to inject a class (Object) from a properties file

Using @ConfigurationProperties on a @Bean method

Using @ConfigurationProperties for property validation