Configure ClimateTrax for k8s local dev

[shon-button]

Install Docker

Docker Desktop on Linux

Install Google Cloud Code

From Visual Studio Code: Click Extension icon Extensions or press Ctrl/Cmd+Shift+X. Search for Google Cloud Code. Click Install.

If prompted, restart VS Code.

After the extension has successfully installed, the Cloud Code icon is added to the activity bar and ready for use. You can further configure your Cloud Code installation by specifying your preferences using the top-level application taskbar: Code > Preferences > Settings > Extensions > Cloud Code.

Create an application from a template

https://cloud.google.com/code/docs/vscode/get-started-k8s

Cloud Code comes with a collection of code sample templates to get you started quickly. To create a Kubernetes application using an existing sample, follow these steps:

• Launch Cloud Code from the right-hand status bar
• Select New Application in the display prompt
• Select Kubernetes application for the type of sample.
• Select a sample based on the language you'd like to use from the available options: NodeJS, Go, Python, Java.
• Choose a preferred application location on your local machine and then click Create new application to save.

Cloud Code clones the sample you chose and opens your new project for use. Sample application structure All language sample applications have nearly the same structure. This is not the only supported structure but is recommended when starting.

For example, the Node.js Guestbook application structure looks like: . |---- .vscode | └---- launch.json |---- kubernetes-manifests | |---- guestbook-backend.deployment.yaml | |---- guestbook-backend.service.yaml | |---- guestbook-frontend.deployment.yaml | |---- guestbook-frontend.service.yaml | |---- mongo.deployment.yaml | └---- mongo.service.yaml |---- src | |---- backend | | |---- Dockerfile | | |---- index.js | | |---- app.js | | └---- package.json | |---- frontend | |---- Dockerfile | |---- index.js | | |---- app.js | └---- package.json └---- skaffold.yaml

Use the README file for instruction to launch the sample app on local Kuberntes

Configuration an existing application

https://cloud.google.com/code/docs/vscode/use-existing-kubernetes-app

If you have an existing application already configured with Kubernetes manifests and a Dockerfile to build your images, you can open and use it with Cloud Code.

The only additional configuration necessary is a skaffold configuration and a launch configuration of type cloudcode.kubernetes. Cloud Code guides you through creating these when you run or debug your application for the first time.

Setting up configuration If your application has a Dockerfile but doesn't have the necessary Skaffold and launch configurations, complete the following steps:

• Click Cloud Code status bar Cloud Code in the status bar and then select Run on Kubernetes or Debug on Kubernetes.
• In the Run/Debug on Kubernetes dialog, specify your preferred builder and its settings. You can also customize your configuration name.
• Click Debug or Run.

The newly created skaffold.yaml and cloudcode.kubernetes launch configuration are added to your workspace and your app runs or is ready for debugging.

Manage secrets with Secret Manager in Cloud Code for VS Code

https://cloud.google.com/code/docs/vscode/secret-manager

bookmark_border With Cloud Code's Secret Manager integration, you can create, view, update, and use secrets in your IDE and without storing them in your codebase.

This page describes how to access Secret Manager in your IDE and how you can get started creating and managing secrets.

Enable Secret Manager API When managing secrets with Cloud Code, secrets are securely stored in Secret Manager and can be programmatically fetched when you need them. All you need is the Secret Manager API enabled and the right permissions to manage secrets:

Make sure that you're working in the project where your application code resides. Your secret must be in the same project as your application code.

Click Cloud Code icon Cloud Code and then expand the Secret Manager explorer.

If you haven't enabled the Secret Manager API, click Enable Secret Manager API in the Secret Manager explorer.

Create secrets To create a secret using the Secret Manager explorer, follow these steps:

In your IDE, click Cloud Code icon Cloud Code and then expand the Secret Manager explorer.

Click add Create Secret in the Secret Manager explorer.

In the Create Secret dialog, set your secret's project, name, value, and region, and specify labels to organize your secrets.

Alternatively, you can create a secret using the editor:

Open a file containing text that you want to store as a secret in the editor. Highlight the text to store as a secret, right-click, and then click Create Secret in Secret Manager. In the Create Secret dialog, customize the secret's project, name, value, region, and labels. Create new versions of secrets To create a new version of a secret using Secret Manager, follow these steps:

Right-click an existing secret and then choose Create Secret Version.

In the Create Version dialog, set the new value of your existing secret using the Secret value field or by importing a file.

To remove all previous versions of your secret and keep just the new version you're creating, choose Disable all past versions.

Click Create Version. Your version is added and you can see the latest secret version and previous versions listed under the Versions dropdowns.

Alternatively, you can create a new version of a secret in the editor:

In the editor, open a file and highlight the text to store as a secret.

Right-click the highlighted text and then choose Add Version to Secret in Secret Manager.

Manage secret versions To enable, disable, or destroy a version of a secret, right-click the secret and then select the command for the action you want to perform. For enabled versions of secrets, you can also view the version's value.

View secrets To view secrets, in the Secret Manager explorer, select a secret from the list. Details of the secret such as name, replication policy, creation timestamp, and resource ID are listed below the secret name.

View secrets in Google Cloud console Alternatively, you can view secrets in Google Cloud console by right-clicking the secret in the Secret Manager explorer and clicking Open in Cloud console.

Right-click secret in Secret Manager to view Open in Google Cloud console option. Properties dropdown also visible in the secret manager view.

View secrets in Kubernetes explorer To view secrets in the Kubernetes explorer, follow these steps:

Click Cloud Code icon Cloud Code and then expand the Kubernetes explorer. Expand your cluster and then expand Secrets. Expand the secret to view its details. Access secrets from your application After your secret is created, you can include it in your code and set up authentication.

To access a secret from your application:

Install the Secret Manager client library.

Click Cloud Code icon Cloud Code and then expand the Cloud APIs explorer.

Expand Cloud Security > Secret Manager API and then follow the instructions in the Install Client Library section for the language you're using.

Customize and include the relevant code snippet in your application's code.

To obtain your secret's version name to use in your code, select the secret in the Secret Manager panel, right-click, and then choose Copy Resource ID.

To complete your authentication setup, follow the Client libraries authentication guide:

Local development: If you're developing on a local cluster (like minikube or Docker Desktop) or a local emulator, you should complete the steps illustrated in the Local development section relevant to your workflow. Remote development: If you're using a GKE cluster or a Cloud Run service in your application, you should complete the steps illustrated in the Remote development section relevant to your workflow, including the Secret Manager-specific instructions for setting up the required roles on your service account. Add a secret as an environment variable To add an existing Kubernetes secret to the deployment as an environment variable, follow these steps:

Click Cloud Code icon Cloud Code and then expand the Kubernetes explorer. Expand your minikube cluster and then expand Secrets. Right-click a secret that represents a deployment object and then click Add Secret as Environment Variable. Mount a secret as a volume To mount an existing Kubernetes secret as a volume in the deployment's container, follow these steps:

Click Cloud Code icon Cloud Code and then expand the Kubernetes explorer. Expand your minikube cluster and then expand Secrets. Right-click a secret that represents a deployment object and then click Mount Secret as Volume. Delete secrets Note: Deleting a secret requires the Secret Admin role (roles/secretmanager.admin) on the secret, project, folder, or organization. IAM roles can't be granted on a secret version. To delete a secret using the Secret Manager in Cloud Code, follow these steps:

Click Cloud Code icon Cloud Code and then expand the Secret Manager explorer.

Right-click an existing secret and select Open in Cloud Console.

On the Secret details page, click DELETE and follow the prompts to delete the secret.

[shon-button]

Example of a Dockerfile for a Next.js version 13 application:

# Use the official Node.js 14 image as the base image
FROM node:14

# Set the working directory inside the container
WORKDIR /app

# Copy the package.json and package-lock.json files to the working directory
COPY package*.json ./

# Install project dependencies
RUN npm ci --only=production

# Copy the Next.js app source code to the working directory
COPY . .

# Build the Next.js app
RUN npm run build

# Expose the specified port for the Next.js app (replace 3000 with your desired port)
EXPOSE 3000

# Start the Next.js app
CMD ["npm", "run", "start"]

Make sure to replace 3000 in the EXPOSE line with the port number your Next.js app uses, if different.

To use this Dockerfile:

Save the above content as a file named Dockerfile (without any file extension) in the root directory of your Next.js project.

Open a terminal or command prompt and navigate to the root directory of your Next.js project.

Build the Docker image by running the following command:

docker build -t your-image-name .

Replace your-image-name with the desired name for your Docker image. Don't forget the . at the end, which indicates the build context is the current directory.

Once the image is built, you can run a container from it using the following command:

docker run -p 3000:3000 your-image-name

Replace your-image-name with the name you used in the previous step. This command maps port 3000 from the container to port 3000 on your local machine. If your Next.js app uses a different port, adjust the command accordingly.

The container should now be running your Next.js version 13 application, and you can access it by opening your browser and navigating to http://localhost:3000 (or the appropriate port number if you changed it).

Note: This example assumes that your Next.js project structure is compatible with Next.js version 13 and that you have already installed the necessary dependencies with npm install.

[shon-button]

Configure a Next.js app Kubernetes manifest for local Minikube

Define the necessary resources such as Deployment, Service, and optionally an Ingress resource.

Here's a step-by-step guide on how to do it:

Create a file named nextjs-app.yaml (or any other name you prefer) and open it in a text editor.

Add the Deployment resource definition. This will specify the desired state of your application's pods. Here's an example .yaml file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nextjs-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nextjs-app
  template:
    metadata:
      labels:
        app: nextjs-app
    spec:
      containers:
        - name: nextjs-app
          image: your-nextjs-app-image:latest
          ports:
            - containerPort: 3000

Replace your-nextjs-app-image with the actual image name and version tag for your Next.js app.

Add the Service resource definition. This will expose your Next.js app within the cluster. Here's an example .yaml file:

apiVersion: v1
kind: Service
metadata:
  name: nextjs-app-service
spec:
  selector:
    app: nextjs-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: NodePort

Optionally, if you want to access your Next.js app using a specific hostname, you can add an Ingress resource. Here's an example .yaml file:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nextjs-app-ingress
spec:
  rules:
    - host: your-hostname.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: nextjs-app-service
                port:
                  number: 80

Replace your-hostname.example.com with the actual hostname you want to use.

Save the nextjs-app.yaml file.

Open a terminal or command prompt and start Minikube by running minikube start.

Apply the Kubernetes manifest to create the resources by running the following command:

kubectl apply -f nextjs-app.yaml

This will create the Deployment, Service, and Ingress (if included) in your Minikube cluster.

Check the status of your resources by running:

kubectl get all

You should see the created Deployment, Service, and Ingress resources, along with their statuses.

Access your Next.js app by using the Minikube IP and the NodePort assigned to the Service. Run the following command to get the URL:

minikube service nextjs-app-service --url

You will see the URL in the output, which you can open in a web browser to access your Next.js app.

That's it! You have successfully configured your Next.js app Kubernetes manifest for local Minikube.

[shon-button]

Debug Cloud Code in Minikube using Visual Studio Code

Follow these steps:

Install the required dependencies:

Install Docker: Make sure you have Docker installed and running on your machine. Install Minikube: Set up Minikube locally and start a Minikube cluster. Install kubectl: Install the Kubernetes command-line tool (kubectl). Install the necessary extensions in Visual Studio Code:

Install the Kubernetes extension: Open Visual Studio Code and install the "Kubernetes" extension developed by Microsoft. Install the Cloud Code extension: Install the "Cloud Code" extension developed by Google. Open your Next.js project in Visual Studio Code.

Configure the Cloud Code extension:

Open the command palette in Visual Studio Code (press Ctrl+Shift+P or Cmd+Shift+P). Type "Cloud Code: Configure Cloud Code" and select the option to configure Cloud Code. Choose the "minikube" option for the cluster type. Provide the cluster context name and the path to your kubeconfig file. Configure the debugging configuration:

Click on the "Debug" tab in Visual Studio Code (left sidebar). Click on the gear icon to open the debug configuration menu and select "Add Configuration". Choose "Kubernetes: Attach to Process" from the available options. Modify the generated configuration as follows: Set the name field to a descriptive name. Set the processName field to the name of the process you want to attach to (e.g., the name of your Next.js app's container). Optionally, you can set the namespace field to specify the Kubernetes namespace if your app runs in a specific namespace. Start Minikube and deploy your Next.js app:

Open a terminal in Visual Studio Code (press Ctrl+backtickorCmd+backtick). Start Minikube by running the minikube start command. Deploy your Next.js app to the Minikube cluster using the appropriate kubectl commands. Make sure to apply the necessary Kubernetes manifest files to create the required resources. Start debugging:

In Visual Studio Code, click on the Debug tab (left sidebar). Choose the debug configuration you created in step 5. Click on the green "Start Debugging" button or press F5 to start the debugging session. Visual Studio Code will attach to the process running inside the Minikube cluster, and you can set breakpoints, step through code, and inspect variables just like you would in a local debugging session. That's it! You should now be able to debug your Next.js app running in Minikube using Visual Studio Code and the Cloud Code extension.