DEV Community: Norbert Fuhs

What is Go 2024 Edition

Norbert Fuhs — Thu, 29 Feb 2024 15:26:41 +0000

Its 2024 and Go also known as Golang gets 15 years old many opensource projects like Kubernetes are built using Go and now its a perfect time to start learning the language. In this blogpost I will provide you some resources learning Go to start your coding journey with it.

What is Go and what is it used for?

Go was created in 2007 by Robert Griesemer, Rob Pike and Ken Thompson at Google and was announced in November 2009.

Go is also known as C for the 21st century and it shares similarities with C programming language. Its pretty easy today to get started with Go and here are some resources so you can start learning it.

Tour of Go
https://go.dev/tour/welcome/1

The Tour of Go lets you start learning Go with simple little exercises learning Go.

Go by Example

https://gobyexample.com/

Go by Example as the name implies shows you Go with coding example anyone can follow.

Getting help learning Go

The Go forum is a great place to ask questions about Go.

https://forum.golangbridge.org/

What about books?

Go In Action is a great book about Go written by William Kennedy , Brain Ketelsen and Erik St. Martin.
You can order it by Manning Publications following the link below.
https://www.manning.com/books/go-in-action

So you now have some resources learning Go if you#re in interested in more blogpost like this comment below and don't forget to follow me on Twitter: https://twitter.com/NorbertFuhs

Thanks for reading have a nice day!

How to start learning Rust in 2024

Norbert Fuhs — Sat, 16 Dec 2023 14:36:58 +0000

Rust is a hot programming language these days and it is easy to get starting with it. A lot of cool software is written using Rust like Deno fror example. This short blogpost will help you getting started learning Rust.

The Book

The first contact point beside the official Rust hompage https://www.rust-lang.org/ is the the Rustlang book: https://doc.rust-lang.org/book/ Here you can start writing small Rust programms and learn the basics of the Rust programming language.

Rust by Example

Rust by Example is another great resource learning to write basic Rust programms. https://doc.rust-lang.org/rust-by-example/

The Youtube channel

There is a Rust youtube channel showing you more advanced Rust concepts. https://www.youtube.com/@RustVideos

Rust in Action

There is a papercopy book written by Tim McNamara providing you with a guide about Rusts basic concepts.

https://www.manning.com/books/rust-in-action

Conclusion

You see there are enough free resources getting started learning Rust I hope you enjouyed this short blogpost.

Netlify Composable Web Platform

Norbert Fuhs — Fri, 27 Oct 2023 19:52:00 +0000

Netlify introduces the Composable Web Platform a new way to to run web architecture.

The Composable Web Platform is built using three parts:

Netlify Connect

Connects all content resources together.

Netlify Core

A frontend cloud solution that accelerates website deployment and speed.

Netlify Create

A visual editor to help to create content faster and easier.

Composable Web Platform is vendor and framework agnostic helping you building a better web expierence.

You can learn more about Composable Web Platform in this blogpost on the Netlify site:

https://www.netlify.com/blog/introducing-the-netlify-composable-web-platform/?utm_content=eyebrow

Hope you enjoyed this blogpost if you would like more content like this feel free to comment below and don't forget to follow me on Twitter: https://twitter.com/NorbertFuhs

What is MinIO? Part 1

Norbert Fuhs — Fri, 08 Sep 2023 17:26:42 +0000

Introduction

Object storage as a Service has got hot these days. Amazon S3 is the market leader right now and the S3 API is the defacto standard for sharing objects in the cloud. MinIO is fully API compatible with Amazon's S3 API and can be easily run in multiple cloud enviroments in this blogpost we will take a look at MinIO basic components.

Key components of MinIO

MinIO Server

MinIO Server. MinIO is a distributed object storage server. It boasts the most comprehensive implementation of the Amazon S3 API to be found anywhere outside of Amazon itself.

MinIO Client

MinIO Client. Is a handy CLI tool managing objects on the MinIO Server this client provides great functionality managing Object Storage in cloud environments. Scripting abilities provide great functionality for DevOps teams.

MinIO Console

MinIO Console. The MinIO Console is a browser-based GUI that incorporates all the functionality of the MinIO Client in a design that feels familiar to IT admins and developers alike.

Conclusion

MinIO is a great way to store unstructered data as objects in th cloud. Powered by Kubernetes its is simple to use in modern cloud enviroments and is a easy and fast way to scale data as objects. With the rise of of AI based systems like Large language models and other ML based tools its a hot choice for cloud based solutions.

Stay tuned for part 2 of the series whre we will dive deeper into managing object-storage data with the use aof MinIO and the programming language Go.

Don't forget to follow me on X Twitter

Setting up Minio as a database for Medusajs

Norbert Fuhs — Fri, 16 Jun 2023 14:49:39 +0000

In this blogpost you'll learn howto setup Minio as database for Medusa.

Introduction

MinIO is a High Performance Object Storage released under GNU Affero General Public License v3.0. It is API compatible with the Amazon S3 cloud storage service. It can handle unstructured data such as photos, videos, log files, backups, and container images with a current maximum supported object size of 5TB.

As beeing compatible with Amazon S3 Minio is a hot choice as data-storage.

Setup Medusa

First we gonna setup Medusajs. You can follow this Quickstart Guide to do so.

Setup Minio

Minio provides many install options you can refer the Documentation Page.

In this case we decide to install Minio and Medusa on macOS.

We're going to use Homebrew:

brew install minio/stable/minio

Starting the Minio Server:

export MINIO_CONFIG_ENV_FILE=/etc/default/minio
minio server --console-address :9090

Changing Minios port

Minios and Medusajs backend both us the same port 9000 to avoid a collision we're going to change Minios port to 9001.

minio server ~/minio --console-address :9090 --address :9001

Create a Minio bucket

We're going to create a bucket storing the Medusajs backend files.

Log into the Minio Console
Click on the create bucket button
Enter the name of the bucket in the Bucket Namefield
Click on the create bucket button
on the buckets page click on the cog icon on the the top to configure the bucket.
Click on the edit icon next to Access Policy.
Change the selected value to public and click Set.

Generate Access Keys

Click on Access Keys from the Minio Console
Click on the "Create access key" button
Tihs is will open up a form with generated keys click on Create button.
A pop-up will show Access-Key and Secret-Key copy both as we will use them later.

Plugin installation

In the folder of your Medusa backend run the following command:

npm install medusa-file-minio

Then add the following environment variables in .env :

MINIO_ENDPOINT=<ENDPOINT>
MINIO_BUCKET=<BUCKET>
MINIO_ACCESS_KEY=<ACCESS_KEY>
MINIO_SECRET_KEY=<SECRET_KEY>

Finally configure medusa-config.js to include the plugin with required options:

const plugins = [
  // ...
  {
    resolve: `medusa-file-minio`,
    options: {
        endpoint: process.env.MINIO_ENDPOINT,
        bucket: process.env.MINIO_BUCKET,
        access_key_id: process.env.MINIO_ACCESS_KEY,
        secret_access_key: process.env.MINIO_SECRET_KEY,
    },
  },
]

Thats it I hope you enjoyed this blogpost about using Minio as database for a Medusajs backend.

Feel free to follow me on Twitter

Whats Medusa an introduction part 3 Modules

Norbert Fuhs — Mon, 29 May 2023 17:32:47 +0000

In this blogpost I will introduce you to Modules and how you can use them.

Modules are self-contained reusable pieces of code which add functionality to your ecommerce application.
Modules increase Medusas extensibilty and can be seen as small units of independent code. Modules can run independently of Medusas core package.

Modules are created and loaded similarly to plugins. They can be loaded from a local project or can be installed from an NPM package.

Create a module

Create a directory with the following structure in it:

custom-module
|
|--index.ts
|
|--services // directory

The directory can be an NPM project but that's optional. index.ts is the entry point to our module. The services directory holds extra services. The following TypeScript configuration file tsconfig.json should be added in the root of the project.

{
  "compilerOptions": {
    "lib": [
      "es2020"
    ],
    "target": "2020",
    "outDir": "./dist",
    "esModuleInterop": true,
    "declaration": true,
    "module": "commonjs",
    "moduleResolution": "node",
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "sourceMap": true,
    "noImplicitReturns": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "noImplicitThis": true,
    "allowJs": true,
    "skipLibCheck": true,
  },
  "include": ["src"],
  "exclude": [
    "dist",
    "./src/**/__tests__",
    "./src/**/__mocks__",
    "./src/**/__fixtures__",
    "node_modules"
  ]
}

Implementing the module

When developing the module you'll later reference the module using a file path to a index.js or index.ts file.
This file acts as an entry point to our module.

Export the module

To use the module withe the medusa backend we need to export it. This is done in the file index.ts the file must export an object with the following properties:

type ModuleExports = {
  service: Constructor<any>
  loaders?: ModuleLoaderFunction[]
  migrations?: any[]
  models?: Constructor<any>[]
  runMigrations?(
    options: LoaderOptions,
    moduleDeclaration: InternalModuleDeclaration
  ): Promise<void>
  revertMigration?(
    options: LoaderOptions,
    moduleDeclaration: InternalModuleDeclaration
  ): Promise<void>
}

Reference module

To use the module in the Medusa backend add your module to medusa-config.js:

module.exports = {
  // ...
  modules: { 
    // ...
    moduleType: {
      resolve: "module-name-or-path", 
      options: {
        // options if necessary
      },
      // optional
      resources: "shared",
    },
  },
}

Module reference

If a module is installed as NPM package the value of the resolve property should be the name of the package:

module.exports = {
  // ...
  modules: { 
    // ...
    moduleType: {
      resolve: "custom-module", 
      // ...
    },
  },
}

Whe using a local module you must reference the module from using an relative file path to ot from the Medusa backend.

|
|---custom module
|   |
|   |---index.ts
|   |
|   |---services
|   |    |
|   |    |---custom-service.ts
|
|
|
---medusa-backend

You can reference your module in two ways:

Referencing the directory the index.ts file is in the root of the directory

medusa-config.js:

module.exports = {
  // ...
  modules: { 
    // ...
    moduleType: {
      resolve: "../custom-module", 
      // ...
    },
  },
}

Referencing the index file medusa-config.js

module.exports = {
  // ...
  modules: { 
    // ...
    moduleType: {
      resolve: "../custom-module/index.ts", 
      // ...
    },
  },
}

Test your module

Test your module running the following command:

npx @medusajs/medusa-cli develop

Howto publish a module

You'll need an NPM account to publish a module.

Create an NPM project

Run the folllowing commands to create a directory and init an NPM project in it:

mkdir my-module
yarn init

A package.json file will be created inside the directory.

Changes to package.json

In your package.json file add the following fields:

{
  // other fields
  "main": "dist/index.js",
  "publishConfig": {
    "access": "public"
  },
  "files": [
    "dist"
  ],
  "devDependencies": {
    "@medusajs/types": "^0.0.2",
    "cross-env": "^5.2.1",
    "typescript": "^4.4.4"
  },
  "scripts": {
    "watch": "tsc --build --watch",
    "prepare": "cross-env NODE_ENV=production npm run build",
    "build": "tsc --build",
  },
  "dependencies": {
    "@medusajs/modules-sdk": "^0.1.0",
  }
}

Configure tsconfig.json

Create a tsconfig.json file in the root of your NPM project:

tsconfig.json

{
  "compilerOptions": {
    "lib": [
      "es2020"
    ],
    "target": "2020",
    "outDir": "./dist",
    "esModuleInterop": true,
    "declaration": true,
    "module": "commonjs",
    "moduleResolution": "node",
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "sourceMap": true,
    "noImplicitReturns": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "noImplicitThis": true,
    "allowJs": true,
    "skipLibCheck": true,
  },
  "include": ["src"],
  "exclude": [
    "dist",
    "./src/**/__tests__",
    "./src/**/__mocks__",
    "./src/**/__fixtures__",
    "node_modules"
  ]
}

Publish and use module

Run prepare command

yarn prepare

npm login

Publish module package

npm publish

Thats all for now on modules in Medusa.js I hope you enjoyed this blogpost.

Whats Medusa an introduction part 2 Next.js storefront

Norbert Fuhs — Sun, 26 Feb 2023 17:43:25 +0000

As we know from part 1 of this series Part 1 Medusajs itself is based on 3 components:

Medusa Server
Admin Dashboard
Storefront

Now we will take a look at howto install and deploy a Storefront based on Next.js. We will start by creating a new Next.js project using the Medusa starter template.

npx create-next-app -e https://github.com/medusajs/nextjs-starter-medusa my-medusa-storefront

Next we change in to the newly created directory my-medusa-storefront and rename the template environment file:

cd my-medusa-storefront
mv .env.template .env.local

Make sure the Medusa Server is running after that it's time to start the Next.js server.

npm run dev

Your new Next.js based storefront is running on https://localhost:8000.

Thats it for this part of the series in the next part we will take a look at customisation of the storefront and learn more about using APIs.

Stay tuned and don't forget to follow me on Twitter.

Whats Medusa an introduction part 1

Norbert Fuhs — Thu, 26 Jan 2023 12:32:41 +0000

In this short blogpost you'll learn about Medusajs the opensource Shopify alternative.

Medusa is based on Node.js and the web framework Express medusajs is hosted on GitHub and written in TypeScript.

Medusa itself is based on three components:

Medusa Server
Admin dashboard
Storefront

Howto install Medusa?

Medusa provide a quickstart method to install a Medusa server which assumed you have Node.js and Git installed on your system.

First we install the Medusa-CLI:

npm install @medusajs/medusa-cli -g

Create a new Medusa project:

medusa new my-medusa-store --seed

Start you Medusa server:

cd my-medusa-store
medusa develop

That's all we need todo to run our Medusa server locally.
Medusa provides different storefronts which are based on Gatsby or Next.js we'll cover in later parts howto setup a storefrontend.

Thats all for now if you liked the blogpost you can comment below or follow me on Twitter

Stay tuned for part 2.

What is Deno Part 1

Norbert Fuhs — Tue, 24 Jan 2023 16:34:19 +0000

In this short blogpost we will take a look at Deno and write some small apps with it.

Introduction

Deno is a runtime for JavaScript , TypeScript which is based on V8 and Rust. It was co-created by Ryan Dahl who also created Node.js. Deno was announced at the JS Conf EU in 2018. In 2022 Deno got a lot of attention recently because since Deno 1.28 it introduced npm-support

Denos advantages over Node.js are TypeScript support out of the box and full compatibility with Web-APIs you can use just like in a normal browser.

To install Deno follow the instructions on the Deno Website once you done this you can write your first Deno program:

console.log("Hello Deno!")

Now you just need to run the deno run command in your terminal to run it:
deno run 01-hello-world.ts

Congratulations you wrote your first Deno programm.

basic webserver

Now we will write a basic webserver using Deno's standard library:

import { serve } from "https://deno.land/std@0.171.0/http/server.ts";

const port = 8080;

const handler = (request: Request): Response => {
  const body = `Your user-agent is:\n\n${
    request.headers.get("user-agent") ?? "Unknown"
  }`;

  return new Response(body, { status: 200 });
};

console.log(`HTTP webserver running. Access it at: http://localhost:8080/`);
await serve(handler, { port });

Note the import statement here we're importing a Deno module just with a weblink using ES modules rather than using Common JS as in Node.js.

You can try the webserver by running deno run --allow-net HTTP-Server.ts note the --allow-net statement here, Deno code runs in a safe sandbox by default so you have to grant permissions for example get net access in your app.

You can now run http://localhost:8080/ and get your displayed which web browser you use.

npm support

Deno support Node.js npm modles which is handy since there not much Deno native modules this days the following example will import the Express framework:

import express from "npm:express@^4.17";
const app = express();

app.get("/", (req, res) => {
  res.send("Hello World");
});

app.listen(3000);
console.log("listening on http://localhost:3000/");

This is the end of the first part a introduction to Deno comment below if you liked it or not based on the comments I will blog a second part soon stay tuned.