DEV Community: Jution Candra Kirana

🚀 [Free or Affordable] Next.js Portfolio Template – Build Your Personal Site in Minutes!

Jution Candra Kirana — Thu, 26 Jun 2025 09:27:21 +0000

🚀 Next.js Portfolio Template – Build Your Personal Site in Minutes!

Hi Devs! 👋

Building a great portfolio website shouldn't take hours of boilerplate work.

That’s why I created this Next.js Portfolio Template — a plug-and-play, modern, responsive solution to help you launch your personal site in minutes.

✨ What’s Inside?

⚙️ Built with Next.js + TailwindCSS
📱 Fully responsive (desktop/tablet/mobile)
🧠 SEO-friendly and fast
📦 Prebuilt Pages:
- Home
- About Me
- Projects
- Skills
- Blog
- Contact
📝 Markdown-powered blog system
🚀 Deploy-ready to Vercel in one click

🎥 Live Demo

Watch the full preview:

👉 https://youtu.be/Lc2vrTBppxw

📥 Download

Get it now for only Rp9.900 (~$0.60)

🔗 https://lynk.id/jutionck/2e0p52r0lx16

Includes:

✅ Source code (.zip)
✅ Simple usage guide
✅ Free minor updates

👀 Who is This For?

Students building their first portfolio
Freelancers & developers needing fast setups
Job seekers applying for dev positions
Creators sharing projects & blogs

🙌 Get Started

Download the template
Open in your code editor
Customize content (texts, colors, images)
Deploy with Vercel or your own host

💬 Let’s Connect

Feel free to:

Leave feedback in the comments
Fork the template and make it better
Tag me if you build with it!

Thanks for reading, and happy building! 🚀

P.S. I'm working on more templates like this. Stay tuned for updates!

Kubernetes: Exec

Jution Candra Kirana — Fri, 18 Oct 2024 08:35:57 +0000

Let's return to the docker material for a moment. In Docker, you can enter a running container using the docker exec command. Similarly, in Kubernetes, you can enter a container within a pod using the kubectl exec command.

Catatan: Since a pod can have more than one container, you can specify the container you want to enter by using the -c {container_name} option. The full command looks like this:

kubectl exec -it {nama_pod} -c {nama_container} -- /bin/sh

So, if you want to enter the container that was created earlier, the command would be:

kubectl exec -it sample-nginx -- /bin/sh

/ # ls
bin                   home                  proc                  sys
dev                   lib                   root                  tmp
docker-entrypoint.d   media                 run                   usr
docker-entrypoint.sh  mnt                   sbin                  var
etc                   opt                   srv
/ #

Kubernetes: Pod

Jution Candra Kirana — Fri, 18 Oct 2024 08:30:39 +0000

Before continuing, make sure you have installed the kubernetesextension shown below:

Once you have it installed, create a new file. Here, we will create a file named pod.yaml. Since you have installed the Kubernetes extension, you don't need to write everything out manually. Just type pod and then press tab, and a pod template will appear as follows:

apiVersion: v1
kind: Pod
metadata:
  name: myapp
  labels:
    name: myapp
spec:
  containers:
    - name: myapp
      image: <Image>
      resources:
        limits:
          memory: '128Mi'
          cpu: '500m'
      ports:
        - containerPort: <Port>

There's no need to memorize the above structure. If you've learned docker, this will be familiar.

In this practice, we will create a pod with the nginx container:

apiVersion: v1
kind: Pod
metadata:
  name: sample-nginx
  labels:
    name: sample-nginx
spec:
  containers:
    - name: sample-nginx
      image: nginx:alpine
      resources:
        limits:
          memory: '10Mi'
          cpu: '10m'
      ports:
        - containerPort: 80

Next, to create the pod defined above, use the commands explained earlier in the POD section.

So, the command will be like this (the pod.yaml file in this practice is located in the sample folder):

kubectl apply -f sample/pod.yaml

If successful, you will see the following information:

pod/sample-nginx created

Then, check the pod using the following command:

kubectl get pod

NAME           READY   STATUS               RESTARTS   AGE
sample-nginx   0/1     ContainerCreating    0          89s

Focus on the STATUS. Here are some common statuses that may appear:

ContainerCreating: Kubernetes is preparing the container for the pod. This process includes pulling the required image (like nginx:alpine), creating the container, and connecting it to the cluster's network. If the pod remains in this status for too long, there may be issues downloading the image or starting the container.
Running: The pod is running, and the container inside it is active. This status indicates that everything is functioning normally.
Pending: The pod is not yet ready to run because one of the preparation steps (like scheduling or image pulling) has not been completed. This usually happens if there are issues scheduling the pod to a node.
Succeeded: The pod has completed successfully, usually used for pods with jobs or cron jobs that have finished executing their tasks.
Failed: The pod has failed to run. The reasons can vary, such as configuration errors or issues with the container itself.
CrashLoopBackOff: The pod continuously fails to start, and Kubernetes is trying to restart the container. This indicates that the container is encountering problems each time it attempts to run.

Next, you can check the details of the created container by running:

kubectl describe pod sample-nginx

After hitting [enter], you will see detailed information about the container.

Next, we will try port-forwarding, which should have been covered in the docker material.

kubectl port-forward pod/sample-nginx 8080:80

Forwarding from 127.0.0.1:8080 -> 80
Forwarding from [::1]:8080 -> 80

Please open your browser to access nginx. Since we have done port-forward, the access will no longer be to port :80 but to port :8080. The complete URL will be localhost:8080, and the result will be as follows:

Kubernetes: Install Tools

Jution Candra Kirana — Fri, 18 Oct 2024 04:24:46 +0000

Minikube

In this practice, we will be using minikube. For more details about minikube, you can check the following URL: https://minikube.sigs.k8s.io/docs/

Follow the installation steps on that website, as the documentation is clear, so no need to write it here hhi :XD.

Once installed, you can start minikube with the following command:

minikube start

If successful, you'll see something like this:I

➜  ~ minikube start
😄  minikube v1.33.1 on Darwin 14.6.1
🆕  Kubernetes 1.30.0 is now available. If you would like to upgrade, specify: --kubernetes-version=v1.30.0
✨  Using the docker driver based on existing profile
👍  Starting "minikube" primary control-plane node in "minikube" cluster
🚜  Pulling base image v0.0.44 ...
🔄  Restarting existing docker container for "minikube" ...

Wait until the process finishes. Once done, you'll see the following information:

...
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Since minikube runs on docker, you can verify it using the docker ps -a command to see that minikube will create one running container.

Note

Minikube is a tool meant for learning purposes and is designed to mimic Kubernetes as closely as possible.

Kubectl

Next, an equally important tool is kubectl. You should have kubectl installed as well. For more information and installation instructions, visit the following URL: https://kubernetes.io/docs/tasks/tools/. Follow the instructions according to your operating system.

Once installed, you can verify by running kubectl version, which should output something like this:

Client Version: v1.30.2
Kustomize Version: v5.0.4-0.20230601165947-6ce0bf390ce3
Server Version: v1.26.1
WARNING: version difference between client (1.30) and server (1.26) exceeds the supported minor version skew of +/-1

After that, we will check if minikube has been set up as a cluster by running the following command:

kubectl config current-context

If successful, the output will look like this:

minikube

Kubernetes: Architecture

Jution Candra Kirana — Fri, 18 Oct 2024 04:14:20 +0000

Master

The Master is the central controller responsible for managing all Nodes in the Kubernetes cluster. It consists of several components working together to orchestrate and manage applications in the form of containers.

ETCD

The first component is etcd, which can be thought of as the "heart" of Kubernetes. etcd serves as a database where all essential information about the cluster is stored. It keeps the configuration and status of applications and nodes in the cluster. If any changes occur, etcd logs them, ensuring that the system is always aware of what’s happening.

API Server

The second component is the API Server, which acts as the main gateway for communication with Kubernetes. All commands and interactions with the Kubernetes cluster go through the API Server. You can interact with Kubernetes via:

Dashboard: A web-based interface.
CLI (Command Line Interface): Such as kubectl to run commands.
API: Allows other programs to control the cluster automatically.

The API Server processes commands, such as creating a pod or modifying configurations, and informs other components to execute the task.

Scheduler

The third component is the Scheduler, which is the "brain" responsible for deciding where a pod (the unit of containers running the application) should be placed in the cluster. The scheduler considers each node’s capacity, like CPU and memory usage, and selects the best node to run the pod.

Controller Manager

The fourth component is the Controller Manager, which ensures that the Kubernetes cluster functions as intended. For example, if a pod dies, the Controller Manager is responsible for creating a new one to ensure the application keeps running.

Node

Nodes are the computers or machines where the application containers are running. Each node has several crucial components that help run and monitor applications.

Container Runtime

The Container Runtime is the engine that runs the containers, such as Docker, containerd, or CRI-O. It is the container runtime that runs the application containers inside the pods. Kubernetes supports multiple container runtimes, enabling the flexibility to run applications inside containers.

Kubelet

The Kubelet is an agent running on every node. Its job is to ensure that all the pods scheduled by the scheduler are running properly on the node. Kubelet regularly checks the pods and reports their status back to the API Server. If there are issues, like a failed pod, Kubelet will either try to fix it or notify the master.

Kube-Proxy

Kube-Proxy is responsible for managing network traffic within the cluster. It ensures that the pods can communicate with each other, whether within the same node or across different nodes. Additionally, Kube-Proxy helps route traffic from outside the cluster to the correct pods.

Kubernetes Master-Node

Worker Node 1	Worker Node 2	Worker Node 3
Kubelet	Kubelet	Kubelet
Kube-Proxy	Kube-Proxy	Kube-Proxy
Container Runtime	Container Runtime	Container Runtime
Pods	Pods	Pods

POD

Pod is the smallest unit in Kubernetes, where one pod can contain more than one container. Each pod has its own IP address, and pods are ephemeral. Ephemeral means that they are not permanent and can be recreated by Kubernetes if needed.

Kubernetes: Introduction

Jution Candra Kirana — Fri, 18 Oct 2024 03:59:48 +0000

Once upon a time, there was a creature known as Kubernetes or k8s. Its creator, let’s call it Google, had vast experience in managing hundreds or even thousands of servers. Google's products, as we know, are accessed by people all over the world, and their performance remains stable. Now, back to Kubernetes. Kubernetes itself is an open-source orchestration tool designed to manage containers, usually for applications at a fairly large scale or beyond.

Kubernetes can ensure no downtime for your application, or at least minimize downtime. It has gained popularity along with the increasing adoption of containers and microservices.

Question?????????? So, can small applications use `Kubernetes`?

Small applications can certainly use Kubernetes, but there are several factors to consider before deciding whether Kubernetes is the right solution:

Complexity: Kubernetes is a powerful tool but can be more complex than simpler solutions like Docker Compose. For small applications, it might take more effort to set up and maintain Kubernetes compared to the benefits you’ll get.
Overhead: Kubernetes requires additional resources to run the control plane, nodes, and networking, which can be excessive for small applications that only need a few containers.
Scalability: Even though the application is small now if the plan is for it to grow and scale quickly, Kubernetes can provide automation, scalability, and reliability advantages for the future.
Operational cost: Managing Kubernetes requires higher operational time and expense, both in infrastructure and in the team maintaining it. Small applications that don’t need high scalability may find more cost-effective solutions elsewhere.

The answer depends on the application's long-term needs. If the small application doesn’t require many containers or high scalability, Kubernetes might feel overkill. However, if there’s a long-term plan to scale, Kubernetes could be a solid investment.

Pssst... the answer above is from ChatGPT... :XD

But in essence, the point is to adjust it to your needs... and of course, money hahaha.

Day 7 - Golang Unit Testing

Jution Candra Kirana — Mon, 04 Sep 2023 06:09:58 +0000

Day 6 - Golang Authentication With JWT

Jution Candra Kirana — Mon, 04 Sep 2023 06:09:26 +0000

Day 5 - Golang Middleware Log With Logrus

Jution Candra Kirana — Mon, 04 Sep 2023 06:08:29 +0000

Day 4 - Golang Database With GORM

Jution Candra Kirana — Mon, 04 Sep 2023 06:07:34 +0000

Day 3 - Golang Database With SQLC

Jution Candra Kirana — Mon, 04 Sep 2023 04:56:00 +0000

Day 2 - Golang Database Native (PostgreSQL)

Jution Candra Kirana — Mon, 04 Sep 2023 04:53:30 +0000