cooshbrown@gmail.com - sandboxdaily.com

archive.php

A simple introduction to Kubernetes

cooshbrown@gmail.comOctober 12, 2024October 12, 2024Docker, Kubernetes, Microservices, MinikubeMinikubeLeave a comment

What you will learn:

In this tutorial you will learn:

Introduction to kubernetes using the simple .net core api image from docker container registry
Basic nderstanding of deployment and service yaml file in kubernetes.
Using minikube

Kubernetes Service and Deployment are two fundamental components of the Kubernetes ecosystem.

The Service acts as the gateway for communication and load balancing. On the other hand, Deployment orchestrates the management and scaling of your application’s replicas.

deploy.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-core-api-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: simple-core-api
  template:
    metadata:
      labels:
        app: simple-core-api
    spec:
      containers:
      - name: simple-core-api
        image: sandboxdaily/simplecoreapi:1.0.0
        imagePullPolicy: Always
        ports:
        - containerPort: 80

$ kubectl apply -f deploy.yml
$ kubectl get pods
NAME                                          READY   STATUS    RESTARTS      AGE
demo-app                                      1/1     Running   4 (22h ago)   13d
simple-core-api-deployment-69bdc96c97-6nj6b   1/1     Running   4 (22h ago)   13d
simple-core-api-deployment-69bdc96c97-kf42t   1/1     Running   4 (22h ago)   13d
simple-core-api-deployment-69bdc96c97-m5mf7   1/1     Running   4 (22h ago)   13d
$ kubectl get deployments
NAME                         READY   UP-TO-DATE   AVAILABLE   AGE
simple-core-api-deployment   3/3     3            3           11d

Note: if kubectl apply -f deploy.yml doesn’t work, run this in console: $ minikube start (see below about minikube)

service.yml

# https://kubernetes.io/docs/concepts/services-networking/service/
apiVersion: v1
kind: Service
metadata:
  name: simple-core-api
spec:
  selector:
    app: simple-core-api
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

$ kubectl apply -f service.yml
$ kubectl get svc
NAME              TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes        ClusterIP      10.96.0.1        <none>        443/TCP        11d
simple-core-api   LoadBalancer   10.104.243.171   127.0.0.1     80:30804/TCP   11d

$ curl http://127.0.0.1/api/values
{"machineName":"simple-core-api-deployment-69bdc96c97-kf42t","environment":null,"logJsonPath":"payloads-base"}

Note: if the api is not working, run this in console: $ minikube tunnel (see below about minikube)

$ kubectl get pods
NAME                                          READY   STATUS    RESTARTS      AGE
demo-app                                      1/1     Running   4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-6nj6b   1/1     Running   4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-kf42t   1/1     Running   4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-m5mf7   1/1     Running   4 (23h ago)   13d
$ kubectl delete pod simple-core-api-deployment-69bdc96c97-6nj6b
pod "simple-core-api-deployment-69bdc96c97-6nj6b" deleted
$ kubectl get pods
NAME                                          READY   STATUS              RESTARTS      AGE
demo-app                                      1/1     Running             4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-kf42t   1/1     Running             4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-m5mf7   1/1     Running             4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-xcr9j   0/1     ContainerCreating   0             2s

$ kubectl get pods
NAME                                          READY   STATUS    RESTARTS      AGE
demo-app                                      1/1     Running   4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-kf42t   1/1     Running   4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-m5mf7   1/1     Running   4 (23h ago)   13d
simple-core-api-deployment-69bdc96c97-xcr9j   1/1     Running   0             69s

What is minikube?

Minikube is a lightweight and simplified version of Kubernetes, primarily used for local development and testing purposes.

What is minikube used for?

You can use Minikube to learn how to deploy and manage applications in Kubernetes.

Minikube can be used to develop Kubernetes applications and test your applications before deploying them to production.

What is the difference between Kubernetes and minikube?

On the Deployment Scale: Kubernetes is designed for large-scale deployments across multiple nodes and clusters, making it suitable for managing complex and distributed environments. On the other hand, Minikube is a lightweight and simplified version of Kubernetes, suitable for local development and testing purposes.

$ minikube start
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│                                                                                                          │
│    You are trying to run the amd64 binary on an M1 system.                                               │
│    Please consider running the darwin/arm64 binary instead.                                              │
│    Download at https://github.com/kubernetes/minikube/releases/download/v1.32.0/minikube-darwin-arm64    │
│                                                                                                          │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
😄  minikube v1.32.0 on Darwin 14.5
🎉  minikube 1.34.0 is available! Download it: https://github.com/kubernetes/minikube/releases/tag/v1.34.0
💡  To disable this notice, run: 'minikube config set WantUpdateNotification false'

✨  Using the docker driver based on existing profile
👍  Starting control plane node minikube in cluster minikube
🚜  Pulling base image ...
🔄  Restarting existing docker container for "minikube" ...
🐳  Preparing Kubernetes v1.28.3 on Docker 24.0.7 ...
🔗  Configuring bridge CNI (Container Networking Interface) ...
🔎  Verifying Kubernetes components...
    ▪ Using image gcr.io/k8s-minikube/storage-provisioner:v5
🌟  Enabled addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

$ minikube tunnel
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│                                                                                                          │
│    You are trying to run the amd64 binary on an M1 system.                                               │
│    Please consider running the darwin/arm64 binary instead.                                              │
│    Download at https://github.com/kubernetes/minikube/releases/download/v1.32.0/minikube-darwin-arm64    │
│                                                                                                          │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✅  Tunnel successfully started

📌  NOTE: Please do not close this terminal as this process must stay alive for the tunnel to be accessible ...

❗  The service/ingress simple-core-api requires privileged ports to be exposed: [80]
🔑  sudo permission will be asked for it.
🏃  Starting tunnel for service simple-core-api.
Password:

References:

docker image: https://hub.docker.com/repository/docker/sandboxdaily/simplecoreapi/general

Build and Push Docker images to Docker hub registry

cooshbrown@gmail.comSeptember 28, 2024October 12, 2024Docker, MicroservicesLeave a comment

Docker Compose 101: use it on Simple .Net Core API

cooshbrown@gmail.comSeptember 28, 2024October 9, 2024.Net Core, Docker, Docker Compose, MicroservicesLeave a comment

Docker Compose is a tool that you will use to define and share multi-container applications. This means you can run a project with multiple containers using a single source, you will need to create a YAML file to define the services you need and run with a single command.

docker-compose.yml

services:
  simplecore.api:
    container_name: simplecoreapi.from.docker.composed
    #image: bindplus.api.v2                # will use image
    image: ${DOCKER_REGISTRY-}simplecoreapi:1.0.0    # will use Dockerfile
    build:
      context: . # ASP-NET-Core-Simple-API replace with the actual name of your project, docker file location
      dockerfile: ASP-NET-Core-Simple-API/Dockerfile
    ports:
      - 49195:80    #[targer port]:[docker file port]

The docker-compose.override.yml is the configuration file where you can override existing settings from the docker-compose.yml or can even add completely new services.

docker-compose.override.yml

services:
  simplecore.api:
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - LogJson__Path=Payload 
    volumes:
      - /tmp/Payload:/app/Payload         # [Local path]:[container path]

Run docker compose using the command: docker compose up -d //daemon

$ docker compose up -d
[+] Running 1/2
 ⠼ Network projects_default                      Created                                                                                                                                                 0.5s 
 ✔ Container simplecoreapi.from.docker.composed  Started

The figure below shows we tested the api if it is running after running docker compose and shutting it down using the command: docker compose down

$ curl http://localhost:49195/api/values
{"machineName":"6ac7227899e2","environment":"Development","logJsonPath":"Payload"}
$ docker compose down
[+] Running 2/2
 ✔ Container simplecoreapi.from.docker.composed  Removed                                                                                                                        0.2s 
 ✔ Network projects_default                      Removed

Dockerize Simple .Net Core API

cooshbrown@gmail.comSeptember 22, 2024September 28, 2024.Net Core, Docker, MicroservicesLeave a comment

Requirements:

Docker Desktop
Git scm
Postman

Build Steps

Step 1: Let’s grab the Simple Core Api project!

Clone the Simple Core API from Github or download the source code.

$ git clone  https://github.com/sandboxdaily/ASP-NET-Core-Simple-API.git

Step 2: Docker File

Let’s add the Dockerfile with this content: (File may be already in the repository)

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443


# This stage is used to build the service project
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
ARG BUILD_CONFIGURATION=Release
WORKDIR /src
COPY ["SimpleCoreApi/SimpleCoreApi.csproj", "SimpleCoreApi/"]
RUN dotnet restore "./SimpleCoreApi/SimpleCoreApi.csproj"
COPY . .
WORKDIR "/src/SimpleCoreApi"
RUN dotnet build "./SimpleCoreApi.csproj" -c $BUILD_CONFIGURATION -o /app/build

# This stage is used to publish the service project to be copied to the final stage
FROM build AS publish
ARG BUILD_CONFIGURATION=Release
RUN dotnet publish "./SimpleCoreApi.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false

# This stage is used in production or when running from VS in regular mode (Default when not using the Debug configuration)
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "SimpleCoreApi.dll"]

Step 3: Docker image

Create docker image using this command: docker build -t [image name] [docker file location]

Example:

docker build -t simplecoreapi:1.0.0 .

Step 4: Docker Container

Create docker container using this command: docker run -d -p [port]:[exposed port] –name [container name] [image name]
Example: (Note it will return the container id)

$ docker run -d -p 2439:80 --name simplecoreapi simplecoreapi:1.0.0
1653c712c4b926ed9f32474dfa80c859ac7d910f9a2202cdadacd5f1da870239

Note: exposed port should be the same as the exposed port in the docker file.

Step 5: Let’s test it!

Testing our container using Postman:

Accessing the files in the container

The snap shot below is from Docker desktop, you can see that the files generated by the api are stored in the payloads-default folder, which is configure in the appsettings.json:

Docker Container Shell

We can also access the files saved using the docker container shell, here I will show you, take note I switched to my windows machine, here’s what I did:

We need to get the container Id using the command: docker ps
Run bash inside the container using the command: docker exec -it 1653 sh //1653 is the first 4 character of the container id
inside the shell, change the directory to payloads-default to list the files created.

C:\SandBoxDaily\ASP-NET-Core-Simple-API>docker ps
CONTAINER ID   IMAGE                 COMMAND                  CREATED          STATUS         PORTS                           NAMES
1653c712c4b9   simplecoreapi:1.0.0   "dotnet SimpleCoreAp…"   11 minutes ago   Up 5 minutes   443/tcp, 0.0.0.0:2439->80/tcp   simplecoreapi

C:\SandBoxDaily\ASP-NET-Core-Simple-API>docker exec -it 1653 sh
#  ls
Microsoft.OpenApi.dll  SimpleCoreApi.deps.json  SimpleCoreApi.pdb                 Swashbuckle.AspNetCore.Swagger.dll     Swashbuckle.AspNetCore.SwaggerUI.dll  appsettings.Staging.json  payloads-default
Newtonsoft.Json.dll    SimpleCoreApi.dll        SimpleCoreApi.runtimeconfig.json  Swashbuckle.AspNetCore.SwaggerGen.dll  appsettings.Development.json          appsettings.json          web.config
# cd payloads-default
# ls
'\20240923121413.json'  '\20240923121633.json'

Copy files from container to local

Command: docker cp [container id] :[container file path] [local destination]

C:\SandBoxDaily>docker cp 1653c712c4b9:/app/appsettings.json .
Successfully copied 2.05kB to C:\SandBoxDaily\.

Copy file from local to container

Command: docker cp [local file] [container id]:[container path]

C:\SandBoxDaily>docker cp helloworld.txt 1653c712c4b9:/app
Successfully copied 2.05kB to 1653c712c4b9:/app

Environment Variables

You can pass environment variables to your containers with the -e (alias --env) flag, e.g. :

Note: Don’t use environment variables to pass sensitive information, such as passwords, in to your containers, use secrets instead.

Example:

# docker run -d -p 2439:80 -e "ASPNETCORE_ENVIRONMENT=Development" -e "LogJson__Path=Payloads" --name simplecoreapi simplecoreapi:1.0.0

In the excerpt of the saved payload below, notice that the values of the Environment and LogJsonPath are from the environment passed.

Note:

· “LogJson__Path=Payloads” is the same as in appsettings.json: “LogJson”: { “Path”: ” payloads” }

· Will work if not assigned/declared in appsettings.json

· Overriding appsettings file

· To override environment variables, remove them from the appsettings file

Docker Volumes

Volumes are a mechanism for storing data outside containers. All volumes are managed by Docker and stored in a dedicated directory on your host, usually /app for Macbook systems.

Volumes are mounted to filesystem paths in your containers. When containers write to a path beneath a volume mount point, the changes will be applied to the volume instead of the container’s writable image layer.

Volume parameters: add -v [local path]:[container path]

$ docker run -d -p 2439:80 -v /tmp/Payloads:/app/Payloads -e "ASPNETCORE_ENVIRONMENT=Development" -e "LogJson__Path=Payloads" --name simplecoreapi simplecoreapi:1.0.0 
703b9d6be839b28d38e0d75232d384b3bcd5b7ad0189d179d16d2356d8a5fa78
$ curl http://localhost:2439/api/values
{"machineName":"703b9d6be839","environment":"Development","logJsonPath":"Payloads"}Augustuss-MacBook-Air:ASP-NET-Core-Simple-API dags$

References:

Build and Push Your Own Docker Images to DockerHub

Create a simple .Net Core API

cooshbrown@gmail.comSeptember 21, 2024October 12, 2024.Net Core

Objective

Our Objective is to create a simple .net core api that we will be using for other tutorials like Dockerizing the api and deploying to azure web api .

The complete source code of the api can be found in here in Github.

I’ve created a new .net core web api project and added new defaul controller and added some codes, see below:

[Route("api/[controller]")]
    [ApiController]
    public class ValuesController : ControllerBase
    {
        private readonly IConfiguration _config;
        public ValuesController(IConfiguration config)
        {
            _config = config;
        }

        [HttpGet]
        public IActionResult Get()
        {
            bool enabledLog;           
            Boolean.TryParse(_config.GetValue<string>("LogJson:Enabled"), out enabledLog);                      

            var logFolder = _config.GetValue<string>("LogJson:Path");

            var result = new
            {
                MachineName = Environment.MachineName,
                Environment = _config.GetValue<string>("ASPNETCORE_ENVIRONMENT"),
                LogJsonPath = logFolder
            };

            if (!enabledLog)
                return Ok(result);

            if (!Directory.Exists(logFolder))
            {
                Directory.CreateDirectory(logFolder);
            }

            var jsonBody = JsonConvert.SerializeObject(result, Newtonsoft.Json.Formatting.Indented);

            if (jsonBody.Length > 0)
            {
                System.IO.File.WriteAllText($"{logFolder}\\{DateTime.Now.ToString("yyyyMMddHHmmss")}.json", jsonBody);
            }

            return Ok(result);
        }

The controller returns a new anonymous object with the following information: Machine name, Environment and the log folder settings (LogJson) :

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "LogJson": {
    "Path": "payloads-default",
    "Enabled": true
  }
}