Forem: Philip Riecks

Remote Java Developer Technical Hardware and Software Setup

Philip Riecks — Fri, 03 Jun 2022 08:15:18 +0000

This article describes my working setup (hardware and software) as a remote freelance Java developer. I've been working from either home, co-working places, or cafes for almost two years. That's why the setup is split into two working modes: working from home and working mobile in a co-working place. On top of the hardware setup, this guide includes the software I'm using on a daily basis.

Disclaimer: The marked links* are affiliate links. If you buy through those links, I get a small cut. I hope that's fine, as I've invested a lot of time and money to find this (at least for me) perfect setup.

Java Developer Work from Home Hardware Setup

Let's start with the hardware setup I'm using when working from home.

I'm working and developing software on a Mac Book Pro M1 2021 16GB Ram 13,3 Inc 512 GB laptop with the touch bar. In the past, I've frequently switched between using Windows, Linux (Ubuntu), and Mac. But I've now stuck to Mac as the tooling support, as well as the integration to my tablet and mobile phone, is perfect. While the price is enormous compared to what you get when buying a similar Windows laptop, I can deduct these expenses as I'm a freelancer.

I went for the 13,3-inch screen size because I frequently work from co-working places or travel by train. A smaller device is better in such situations. After solving some initial hurdles as a Java developer working with an M1 chip (arm64), I'm now really productive with this laptop, and it's super fast and slim (good for travel).

The MacBook is connected to a docking station (Raidsonic ICY BOX IB-DK2245AC) via USB-C and to an external monitor. As I'm frequently changing workplaces, I want a smooth transition without many cables resorting. I can just remove the docking station cable and put the laptop into my bag.

The screen is a DELL S2721QS (27″) 4K TFT*. I'm fine with having two screens in total: one external monitor and the integrated Mac screen. While the monitor allows for 4k resolution, I usually use a 1920×1080 resolution.

The laptop stand for my WFH setup is a solid non-adjustable: Rain Design mStand*. To organize my desk, I'm using an IKEA stand (ELLOVEN) for the external monitor. With this stand, I can additionally store some pencils, paper, cables, and USB sticks.

All this hardware is placed on a 200x80cm height-adjustable desk from IKEA (BEKANT):

I try to balance the time sitting and standing every day. There's no better investment than investing in your health and work setup that will last.

The chair is also from IKEA (LÅNGFJÄLL) and is both stylish and comfortable.

As I'm regularly organizing and scanning receipts, I've bought the Brother MFC-L2750DW*. This printer works with AirPrint (Apple's printing solution) and has some built-in apps to scan a document, convert it to PDF and directly upload it to a OneDrive folder.

As a fallback solution, I still have a desktop machine. This is an Ubuntu 20.04 with 16 GB RAM and an i7. If my main laptop has issues, I can easily switch to another machine. On top of this, I sometimes use the Ubuntu machine if there's no compatibility with the Apple M1 chips for any enterprise software of my clients.

This article is written on an Apple magic keyboard* while using the Logitech MX Master 3* mouse. I'm not into those mechanical keyboards and enjoy the slim design of Apple's keyboard.

I started with the Logitech MX Keys keyboard* but switched to the Apple one. The Logitech MX Keys keyboard is still used for working with my Ubuntu machine. Both the MX keyboard and mouse have a neat feature to connect to up to three devices and switch the current machine context with just a click.

For meetings and calls, I'm using a Jabra Evolve 75 headset. For sharing a picture of myself in those calls, I'm either using the built-in camera of the MacBook Pro or a cheap 1080p camera*. This USB camera does its job well, but I might soon upgrade to a new one.

The underlying matt* is from Amazon, and it helps me to keep the desk surface protected and works perfectly with the mouse.

Java Developer Mobile Co-Working Hardware Setup

When I'm out of home, I slightly change the hardware setup. The co-working spaces and cafes usually don't offer any external monitors. That's why I have to improvise and find a good balance between carrying too much hardware with me and having a healthy setup.

I've recently bought the Nextstand V2 laptop stand*. This allows me to have good posture as I'm looking up straight into the laptop and not down. The downside of using a laptop stand is that you have to carry a keyboard and mouse; otherwise, typing will be hard.

The Apple magic keyboard and the Logitech MX Master 3 mouse are both lightweight, comfortable, and easy to travel with:

If I need a second monitor, I connect my iPad Pro 11″ as an external screen for my Mac Book Pro. The Mac comes with a built-in feature for this.

I'm using either the Apple AirPods Pro* or the regular Apple headphones for calls and listening to music. Most co-working places offer phone booths that ensure there's no background noise.

Some additional accessories I'm using for this mobile working setup are:

When traveling, I switch between these three bags:

JOOP! Treviso Pandion Briefbag S Black
Backpack from onemate: Discovery
Brown laptop bag from s.Oliver

Online Course Recording Setup (Hardware & Software)

As I'm creating video content for both YouTube and my online course platform, I'm recording audio every now and then. I started with an external mic, as many streamers or podcasters have. This microphone was attached to a microphone stand and attached to my desk.

While this worked fine, I recently switched to a headset for my recordings. For me, this feels handier. I only have to switch on the headset and can start the recording. No need for an adjustment of the microphone, and I can move back and forth in my chair without affecting the sound quality.

The headset I'm using is a beyerdynamic DT-797:

However, I can't wear this for more than 2 hours straight because of the pressure on my head. The headset rests safely on a stylish headphone stand* from Amazon.

To convert the analog audio signal from this beyerdynamic headset, I'm using a Focusrite Scarlett 2i2 3rd Gen Audio Interface*. This lets me plug in the headset via USB-C to my docking station.

I'm using Screenflow to record and edit all the content I create on the Mac laptop. When working with my fallback Ubuntu Desktop for recording, I'm using Kazam, Audacity, and kdenlive.

Software for Java Development

Let's continue with the software part of my setup as a Java developer.

The application I spent the most time during the day is my IDE. I'm using IntelliJ IDEA with the following must-have plugins:

AsciiDoc (as I'm writing some of my ebooks in Asciidoc)
Presentation Assistant to show a toast notification whenever I use shortcuts
SonarLint for basic code hints
Key Promoter X to learn more IDEA shortcuts

I switched from Eclipse to IntelliJ five years ago and have never looked back since. I'm using their Ultimate license and really enjoy the productivity gain and features of this IDE.

I use jEnv to manage various Java installations (I guess it's time for me to get to know sdkman) and easily switch between Java versions. With jEnv, you can place .java-version file in the root of each project and define which Java version to use. When navigating to a folder with such file, jEnv configures your shell session to use the selected Java version. It falls back to a globally configured Java version if no Java version is defined.

For the shell, I'm using zsh with Oh My Zsh. I'm using the default theme robbyrussell, and the following plugins: git, zsh-autosuggestions, zsh-syntax-highlighting and history.

I've installed iTerm2 as a replacement for the macOS native terminal. The main reason is the split pane feature that allows me to run multiple shell sessions on a single screen.

When editing files on a remote server, I prefer vim over emacs. However, I'm not a vim ninja, but I feel comfortable editing config files with it.

For quick project investigations or when writing blog posts in Markdown, I prefer VS Code. I have installed the following extensions:

Docker
Extension Pack for Java
Debugger for Java
Language Support for Java by Red Hat
Maven for Java
Intellij IDEA Keybindings
Grammarly

Next, I'm using Postman for tinkering and exploring the API for systems that I'm about to integrate. I've created an account on their site to share my API collections among multiple machines potentially.

Last but not least, I've installed Docker Desktop for Mac. As I'm a sole trader, I don't fall into Docker's new licensing agreement and can continue to use their desktop installation for Mac. However, as one of the main reasons for me to use Docker locally is to run tests with Testcontainers, I'm using Testcontainers Cloud whenever I can. This tool lets me run my Testcontainers integration test locally without the need for a Docker engine, and it speeds things up when I'm on bad WiFi.

Java Developer Utility & Productivity Software

Let's finish this hardware and software guide for Java developers with some utility and productivity software I'm using on a daily basis. Some of them are not directly related to software development. However, they help me stay productive or organize my workday.

First, my primary browser is Firefox. I'm using Firefox also on my mobile devices and syncing my bookmarks to, e.g., read interesting articles on a train ride after having bookmarked them on my laptop. I use Chrome and Safari less frequently and mainly for testing purposes of my blog and applications.

For messaging and coordinating in a remote and asynchronous world, I favor Slack. If I'm not working for a client, I never have Slack open all the time and instead open it every two or three hours to stay focused on my current task.

I'm using the Google Workspace to organize my solo company and use the Gmail web view for managing emails.

On top of Google Workspace, I still have an Office365 subscription. The main reason for this subscription is the fact that I can share the office applications with up to five people and get 1 TB of OneDrive cloud storage. I use OneDrive for most of my personal files.

To quickly adjust and split any application window, I use Rectangle. This simple application allows adjusting the sizing of windows and quickly placing two next together, for example.

Another small and super helpful macOS tool is Maccy. This clipboard manager on steroids keeps a history of all my clipboards and lets me efficiently use a previous one.

To quickly record my screen or share screenshots, I'm using CloudApp*. Once you finish the recording or take a screenshot, the tool will immediately upload the content, and you get a sharable public URL. This is helpful when working with a support team to share error reports.

For all my personal notes, checklists, and book summaries, I'm using Notion. Notion lets you organize your content with Markdown-based files and offers an intuitive and fast user interface natively, in the browser and on mobile devices.

Spotify is another application that I immediately install when setting up a new machine. Listening to music helps me get into the tunnel and stay focussed. For deep work and when doing creative tasks, I prefer piano music. For all other tasks, I frequently mix the music genre.

All my passwords are stored within the password manager Dashlane*. Dashlane comes with a browser extension for every major browser and also seamlessly integrates with the iOS password manager. The times of noting down my password with pen and paper are over. With the help of a password manager, you can max out the security requirements for all passwords as you don't have to remember them.

For organizing my workday and task planning, I use Kanbanflow. I plan all my days ahead and split the tasks into 25-minutes pomodori (Pomodoro Technique) chunks. The tool runs as a web application in the browser and comes with a Pomodoro timer that I use to know when it's time to work and when it's time for a break.

Finally, I use both Grammarly and DeepL for translations and proofreading.

Joyful testing,

Philip

Write Spring Boot integration tests with Testcontainers (JUnit 4 & 5)

Philip Riecks — Thu, 02 Jul 2020 17:19:15 +0000

Recently, I was looking for a solution to write integration tests for my Spring Boot-based application which was using PostgreSQL. I had the following requirements for this task:

The integration tests should use the same database as in production (referring to the Twelve-Factor App I wanted to keep my environment during the tests as similar as possible to the production environment)
The tests should not need any pre-setup before running (e.g. like manually setting up a test database)
The tests should use my Flyway DDL scripts and create-drop (spring.jpa.hibernate.ddl-auto) shouldn't be activated for my tests
Good integration with the excellent Spring tests ecosystem

For this task, I found the awesome project: Test containers. The project describes itself as the following:

"Testcontainers is a Java library that supports JUnit tests, providing lightweight, throwaway instances of common databases, Selenium web browsers, or anything else that can run in a Docker container."

With this blog post, we'll use Testcontainers to write integration tests with JUnit using a real database (meaning not mocked or in-memory) for a Spring Boot application.

UPDATE: Time flies and a lot was introduced since I published this blog post. Therefore I added integration test examples for different combinations of JUnit 4 & 5 and Spring Boot versions.

Setup Testcontainers in Spring Boot project

For using this dependency you need to have Docker on your local machine/on your build server (Jenkins etc.).

With Testcontainers you can use a @ClassRule or @Rule on each of your integration tests and define the Docker image for your test (valid for JUnit 4.12).

For MySQL and PostgreSQL and there are already built-in solutions but you are free to use an image of your choice like the following:

// generic container for self-defined Docker images
@ClassRule
public static GenericContainer redis = new GenericContainer("redis:3.0.6").withExposedPorts(6379);

// built-in containers
@ClassRule
public static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer().withPassword("inmemory")
            .withUsername("inmemory");

To run the integrations tests after your unit tests, simply add maven-failsafe-plugin to your project. In addition, make sure your integration tests have IT as a postfix:

<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-failsafe-plugin</artifactId>
      <version>3.0.0-M4</version>
      <executions>
        <execution>
          <goals>
            <goal>integration-test</goal>
            <goal>verify</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

Basic application integration test with Testcontainers

Using: JUnit 4.12 and Spring Boot < 2.2.6

Let's start with the integration test each Spring Boot application contains out-of-the-box. This integration test verifies that Spring can create the context and start the application.

As our application requires a PostgreSQL to be available during startup, we can provide one using Testcontainers. Overriding the properties to use the PostgreSQL database spawned by Testcontainers is as easy as the following:

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ContextConfiguration(initializers = IntegrationTest.Initializer.class)
public class ApplicationIT {

    @ClassRule
    public static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer().withPassword("inmemory")
            .withUsername("inmemory");

    public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

        @Override
        public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
            TestPropertyValues values = TestPropertyValues.of(
                    "spring.datasource.url=" + postgreSQLContainer.getJdbcUrl(),
                    "spring.datasource.password=" + postgreSQLContainer.getPassword(),
                    "spring.datasource.username=" + postgreSQLContainer.getUsername()
            );
            values.applyTo(configurableApplicationContext);
        }
    }

    @Ŧest
    public void contextLoads() {
    }
}

Basic application integration test with JUnit 5 and Spring Boot > 2.2.6

If your application uses JUnit 5, you can't use the @ClassRule anymore. Fortunately, Testcontainers provides a solution to write tests with JUnit Jupiter:

<dependency>
  <groupId>org.testcontainers</groupId>
  <artifactId>junit-jupiter</artifactId>
  <version>${testcontainers.version}</version>
  <scope>test</scope>
</dependency>

With this dependency and a more recent version of Spring Boot (> 2.2.6) the basic integration test looks like the following:

// JUnit 5 example with Spring Boot >= 2.2.6
@Testcontainers
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class ApplicationIT {

  @Container
  public static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer()
    .withPassword("inmemory")
    .withUsername("inmemory");

  @DynamicPropertySource
  static void postgresqlProperties(DynamicPropertyRegistry registry) {
    registry.add("spring.datasource.url", postgreSQLContainer::getJdbcUrl);
    registry.add("spring.datasource.password", postgreSQLContainer::getPassword);
    registry.add("spring.datasource.username", postgreSQLContainer::getUsername);
  }

  @Test
  public void contextLoads() {
  }

}

Integration test with JUnit 5 and Spring Boot < 2.2.6

If your application makes use of JUnit 5 but is using a Spring Boot version < 2.2.6, you don't have access to the @DynamicPropertySource feature.

A possible integration test to verify a REST API endpoint is working as expected looks like the following:

// JUnit 5 example with Spring Boot < 2.2.6
@Testcontainers
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@ContextConfiguration(initializers = DeletePersonIT.Initializer.class)
public class DeletePersonIT {

  @Container
  public static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer()
    .withPassword("inmemory")
    .withUsername("inmemory");

  @Autowired
  private PersonRepository personRepository;

  @Autowired
  public TestRestTemplate testRestTemplate;

  public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
      TestPropertyValues values = TestPropertyValues.of(
        "spring.datasource.url=" + postgreSQLContainer.getJdbcUrl(),
        "spring.datasource.password=" + postgreSQLContainer.getPassword(),
        "spring.datasource.username=" + postgreSQLContainer.getUsername()
      );
      values.applyTo(configurableApplicationContext);
    }
  }

  @Test
  @Sql("/testdata/FILL_FOUR_PERSONS.sql")
  public void testDeletePerson() {
    testRestTemplate.delete("/api/persons/1");
    assertEquals(3, personRepository.findAll().size());
    assertFalse(personRepository.findAll().contains("Phil"));

  }
}

You can find more integration test examples for this demo Spring Boot CRUD API application using PostgreSQL on GitHub.

Further integration test-related tutorials for Spring Boot:

Happy integration-testing with Spring Boot, Testcontainers and JUnit,
Phil

Deploy a React application to Kubernetes in 5 easy steps

Philip Riecks — Tue, 09 Jul 2019 09:55:50 +0000

Kubernetes is currently the de-facto standard for deploying applications in the cloud. Every major cloud provider offers a dedicated Kubernetes service (eg. Google Cloud with GKE, AWS with EKS, etc.) to deploy applications in a Kubernetes cluster.

There are many reasons for choosing Kubernetes for deploying your React application:

unified and standardized deployment model across the cloud providers
robustness against downtime as several containers are deployed (horizontal scaling)
handling peak traffic with auto-scaling
zero-downtime deployments, canary deployments, etc.
simple A/B testing

With this post, I'll demonstrate how to deploy a React application to a Kubernetes cluster with five easy steps. To follow the article you just need basic Docker knowledge.

As we all want quick feedback while learning a new topic I'll use a local Kubernetes cluster for this example. You can spin up this local Kubernetes cluster in minutes if you have a Docker engine with Kubernetes support installed on your machine. This is available since version 18.06.0 for both Docker Desktop for Windows/Mac.

Let's get started...

Step 1: Create the React application

I start off with a fresh React application created with create-react-app from Facebook:



➜ node -v
v10.16.0
➜ npm -v
6.9.0
➜ npx create-react-app react-app-kubernetes
npx: installed 91 in 5.787s

Creating a new React app in /Users/rieckpil/Desktop/react-app-kubernetes.

Installing packages. This might take a couple of minutes.
Installing react, react-dom, and react-scripts...

...

Happy hacking!

This will create all the required configuration and files to start developing a new React application.

Make sure you are able to start and access the React application on your local machine at http://localhost:3000 using npm start. For the further sections, we need the optimized production build of the React application which is created with:



➜ npm run-script build
> react-app-kubernetes@0.1.0 build /Users/rieckpil/Desktop/junk/react-app-kubernetes
> react-scripts build

Creating an optimized production build...
Compiled successfully.

File sizes after gzip:

  36.44 KB  build/static/js/2.b41502e9.chunk.js
  762 B     build/static/js/runtime~main.a8a9905a.js
  602 B     build/static/js/main.28647029.chunk.js
  517 B     build/static/css/main.2cce8147.chunk.css

...

If you have an existing React application you can skip this section and continue with the next one. Just make sure you have the production build of your application available at build/.

Step 2: Dockerize the React application

For deploying the React application to Kubernetes, we need to package it inside a container. Kubernetes supports several container engines, but Docker is currently the most adopted one.

To create a Docker container we need a Dockerfile at the root level of our React application folder. This file defines what OS is used, how it is configured and what other applications are running inside this container.

For this example, I'm using nginx to serve the content of the React application and the simplest Dockerfile looks like the following:



FROM nginx:1.17
COPY build/ /usr/share/nginx/html

Our Docker container inherits everything from the official nginx:1.17 Docker image and just copies the React production build to the container.

To speed up the creation of the Docker container, make sure you add a .dockerignore to your project to exclude the node_modules from being sent to the Docker context:



node_modules

Once you have your React production build in place, start your Docker engine and execute the following command to create the Docker image:



➜ docker build -t my-react-app .
Step 1/2 : FROM nginx:1.17
1.17: Pulling from library/nginx
fc7181108d40: Pull complete
d2e987ca2267: Pull complete
0b760b431b11: Pull complete
Digest: sha256:96fb261b66270b900ea5a2c17a26abbfabe95506e73c3a3c65869a6dbe83223a
Status: Downloaded newer image for nginx:1.17
 ---> f68d6e55e065
Step 2/2 : COPY build/ /usr/share/nginx/html
 ---> 35d48f28a918
Successfully built 35d48f28a918
Successfully tagged my-react-app:latest

For a more production-ready Docker container, make sure you customize the nginx configuration for your needs.

Step 3: Connect to your Kubernetes cluster

To start your local Kubernetes cluster, open the Docker Desktop preferences and switch to the Kubernetes tab:

Here you can enable the Kubernetes support. If you enable it for the first time, the cluster creation may take some time, as several Docker images are downloaded in the background.

Once your local Kubernetes cluster is running, connect to it via kubectl (if missing, download here):



➜ kubectl config use-context docker-for-desktop
Switched to context "docker-for-desktop".
➜ kubectl get nodes
NAME                 STATUS    ROLES     AGE       VERSION
docker-for-desktop   Ready     master    3d        v1.10.11
➜ kubectl cluster-info
Kubernetes master is running at https://localhost:6443
KubeDNS is running at https://localhost:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

With this Kubernetes support of Docker Desktop you'll get a local single node cluster which is nice for evaluation and learning purposes.

If you want to deploy your React application to a Kubernetes cluster in the cloud, start here:

Google Kubernetes Engine (GKE) quickstart
Azure Kubernetes Engine (AKS) quickstart
AWS Kubernetes Engine (EKS) quickstart
Oracle Container Engine for Kubernetes (OKE) quickstart

Step 4: Upload the Docker image to your container registry

To be able to pull the Docker image within the Kubernetes cluster, we need to upload the image to a Docker registry. For a cloud deployment, you usually get a dedicated registry from the cloud provider to upload your image. As we are deploying the application to a local cluster, we need a local Docker registry.

You can create a local Docker registry with the following statement:



➜ docker run -d -p 5000:5000 --restart=always --name registry registry:2

For uploading our previously created React Docker image, we have to tag the image with the hostname and port of the registry:



➜ docker tag my-react-app localhost:5000/my-react-app

And can now finally push the image to our Docker registry:



➜ docker push localhost:5000/my-react-app
The push refers to repository [localhost:5000/my-react-app]
9d9745936581: Pushed
d2f0b6dea592: Pushed
197c666de9dd: Pushed
cf5b3c6798f7: Pushed
latest: digest: sha256:66c94bdba6b06d1964a764cd14dc97d8adf202b02ab6e6fbd10b23ad4a8554a1 size: 1158

Now we are ready to deploy the application to the Kubernetes cluster.

Step 5: Deploy the React application

Usually, every Kubernetes object (service, pod, deployment, etc.) is described in a .yaml file but .json is also possible.

For deploying the React application to Kubernetes we need a so-called deployment. This Kubernetes entity makes sure our application will have as many replicas (parallel pods) as we define. In addition, we can define the Docker image we want to use, what ports are used and further metadata for our application:



kind: Deployment
apiVersion: apps/v1
metadata:
  name: my-react-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-react-app
  template:
    metadata:
      labels:
        app: my-react-app
    spec:
      containers:
        - name: my-react-app
          image: localhost:5000/my-react-app
          imagePullPolicy: Always
          ports:
            - containerPort: 80
      restartPolicy: Always

With just the deployment we wouldn't be able to access our application from outside. To expose applications, Kubernetes offers a so-called service. Using a service we can define which ports to expose to the cluster/outside.

There are several different types of a Kuberntes service and I'm choosing the simplest one for your example: NodePort. This type will expose a defined port on every node in our Kubernetes cluster (with the local Kubernetes cluster, we just have one node) and map it to an application's port:



kind: Service
apiVersion: v1
metadata:
  name: my-react-app
spec:
  type: NodePort
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
      nodePort: 31000
  selector:
    app: my-react-app

Both the service and deployment can be added to a single .yaml file with a --- for separation. In our example, I've created one deployment.yaml file to store both:



kind: Deployment
apiVersion: apps/v1
# more ...
---
kind: Service
apiVersion: v1
# more ...

You can now use this file to deploy your application to Kubernetes with:



➜ kubectl apply -f deployment.yaml
deployment.apps "my-react-app" created
service "my-react-app" created

And can check that everything is running using:



➜ kubectl get pods
NAME                            READY     STATUS    RESTARTS   AGE
my-react-app-6c8b5c4759-fgb2q   1/1       Running   0          7m
my-react-app-6c8b5c4759-jrzzj   1/1       Running   0          7m
➜ kubectl get deployment
NAME           DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
my-react-app   2         2         2            2           7m
➜ kubectl get service
NAME           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes     ClusterIP   10.96.0.1       <none>        443/TCP        3d
my-react-app   NodePort    10.99.224.141   <none>        80:31000/TCP   7m

Once everything is up and running, visit http://localhost:31000 on your machine and you should see your React application, now served from a Kubernetes cluster:

To remove the React application from your Kubernetes cluster, just run



➜ kubectl delete service,deployment my-react-app
service "my-react-app" deleted
deployment.extensions "my-react-app" deleted

You can find the whole codebase for this example on GitHub.

For further React related posts, visit my blog:

Have fun deploying your React applications to Kubernetes,
Phil