Forem: Chris Noring

Getting started with GitHub Copilot part 2, streamable responses

Chris Noring — Mon, 16 Mar 2026 20:14:28 +0000

I'm sure you've seen many AI apps where you sit tight for 30s or and you wonder if things are stuck? Not a great experience right? Yes, you're right, you deserve better, so how do we fix it?

Type your prompt> Tell me a joke
.
.
.
.
.
.
.
.
Why could I never find the atoms, cause they split..

Series on Copilot SDK

This series is about Copilot SDK and how you can leverage your existing GitHub Copilot license to integrate AI into your apps

Part 1 - install and your first app
Part 2 - streamable response, you're here

Addressing the problem

By streaming the response, the response now arrives in chunks, pieces that you can show as soon as they arrive. How can we do that though and how can GitHub Copilot SDK help out?

Well, there's two things you need to do:

Enable streaming. You need to set streaming to True when you call create_session.
Listen for events that contains a chunk. Specifically, you need to listen to ASSISTANT_MESSAGE_DELTA and print out the chunk.

# 1. Enable streaming
session = await client.create_session({
        "model": "gpt-4.1",
        "on_permission_request": PermissionHandler.approve_all,
        "streaming": True,
    })

print("Starting streamed response:")

# Listen for response chunks
def handle_event(event):
    if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
        // 2. Chunk arrived, print it
        sys.stdout.write(event.data.delta_content)
        sys.stdout.flush()
    if event.type == SessionEventType.SESSION_IDLE:
        print()  # New line when done

Here's what the full application looks like:

import asyncio
import sys
from copilot import CopilotClient, PermissionHandler
from copilot.generated.session_events import SessionEventType

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({
        "model": "gpt-4.1",
        "on_permission_request": PermissionHandler.approve_all,
        "streaming": True,
    })

    print("Starting streamed response:")

    # Listen for response chunks
    def handle_event(event):
        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
            sys.stdout.write(event.data.delta_content)
            sys.stdout.flush()
        if event.type == SessionEventType.SESSION_IDLE:
            print()  # New line when done

    session.on(handle_event)

    print("Sending prompt...")
    await session.send_and_wait({"prompt": "Tell me a short joke"})

    await client.stop()

if __name__ == "__main__":
    asyncio.run(main())

That's it folks, now go out and build better experiences for your users.

Don't miss this opportunity to learn more about GitHub Copilot CLI

Chris Noring — Sun, 08 Mar 2026 22:24:48 +0000

Renee Noble for Microsoft Azure

Mar 5

Get started with GitHub Copilot CLI: A free, hands-on course

#githubcopilot #cli #vscode #terminal

Comments

4 min read

Get started with GitHub Copilot SDK, part 1

Chris Noring — Wed, 04 Mar 2026 20:48:00 +0000

Did you know GitHub Copilot now has an SDK and that you can leverage your existing license to build AI integrations into your app? No, well I hope I have you attention now.

Series on Copilot SDK

This series is about Copilot SDK and how you can leverage your existing GitHub Copilot license to integrate AI into your apps

Part 1 - install and your first app, you're here
Part 2 - streamable responses

Install

You need two pieces here to get started:

GitHub Copilot CLI
A supported runtime, which at present means either Node.js, .NET, Python or Go

Then you need to install the SDK for your chosen runtime like so:

pip install github-copilot-sdk

The parts

So what do you need to know to get started? There are three concepts:

Client, you need to create and instance of it. Additionally you need to start and stop it when you're done with it.
Session. The session takes an object where you can set things like model, system prompt and more. Also, the session is what you talk when you want to carry out a request.
Response. The response contains your LLM response.

Below is an example program using these three concepts. As you can see we choose "gpt-4.1" as model but this can be changed. See also how we pass the prompt to the function send_and_wait.

import asyncio
from copilot import CopilotClient

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({"model": "gpt-4.1"})
    response = await session.send_and_wait({"prompt": "What is 2 + 2?"})

    print(response.data.content)

    await client.stop()

asyncio.run(main())

Ok, now that we know what a simple program looks like, let's make something interesting, an FAQ responder.

Your first app

An FAQ for a web page, is often a pretty boring read. A way to make that more interesting for the end user is if they can instead chat with the FAQ, let's make that happen.

Here's the plan:

Define a static FAQ
Add the FAQ as part of the prompt.
Make a request to to the LLM and print out the response.

Let's build out the code little by little. First, let's define the FAQ information.

-1- FAQ information

# faq.py

faq = {
  "warranty": "Our products come with a 1-year warranty covering manufacturing defects. Please contact our support team for assistance.",
  "return_policy": "We offer a 30-day return policy for unused products in their original packaging. To initiate a return, please visit our returns page and follow the instructions.",     
  "shipping": "We offer free standard shipping on all orders over $50. Expedited shipping options are available at checkout for an additional fee.",
}

Next, let's add the call to the Copilot SDK

-2 Adding the LLM call


import asyncio
from copilot import CopilotClient

def faq_to_string(faq: dict) -> str:
    return "\n".join([f"{key}: {value}" for key, value in faq.items()])

async def main(user_prompt: str = "Tell me about shipping"):
    client = CopilotClient()
    await client.start()

    prompt = f"Here's the FAQ, {faq_to_string(faq)}\n\nUser question: {user_prompt}\nAnswer:"   

    session = await client.create_session({"model": "gpt-4.1"})
    response = await session.send_and_wait({"prompt": prompt})

    print(response.data.content)

    await client.stop()

if __name__ == "__main__":
    print("My first app using the GitHub Copilot SDK!")
    print(f"[LOG] Asking the model about shipping information...")
    asyncio.run(main("Tell me about shipping"))

Note how we concatenate the FAQ data with the user's prompt:

 prompt = f"Here's the FAQ, {faq_to_string(faq)}\n\nUser question: {user_prompt}\nAnswer:"

-3- Let's run it

Now run it:

uv run faq.py

You should see output like so:

My first app using the GitHub Copilot SDK!
[LOG] Asking the model about shipping information...
We offer free standard shipping on all orders over $50. Expedited shipping options are available at checkout for an additional fee.

What's next

Check out the official docs

How YOU can build a Web API in Java and Spring boot

Chris Noring — Tue, 06 Dec 2022 21:49:02 +0000

Build a Web API in Java and Spring boot

In this article you will learn to:

Configure your Visual Studio code environment for usage with Spring Boot.
Create a Spring boot project.
Learn how Spring enables you to create a REST API.
Document your API via Swagger and Open API specification.

Prereqs

You should have the following installed:

Java
Maven, a building tool for building projects and maintaining dependencies
Visual Studio Code

Configure Visual Studio via extensions

To make it easier to work with development of Web APIs in Java, you can install a set of extensions. These extensions will help you with tooling support around auto completion but also stopping starting and debugging your web apps.

You need these two extensions:

which will install the following:

Java development kit JDK
Extension Pack for Java
Spring Boot Extension Pack, specific tooling around using Spring Boot.

To learn more on developing with Java using Visual Studio Code, go to:

https://code.visualstudio.com/docs/java/java-spring-boot

Exercise: Create a Spring boot project

Once you've installed the extensions needed you can use the command palette in Visual Studio Code to scaffold your Spring Boot project.

Bring up the command pallette (View -> Command Palette) and choose the following command:
```
Spring Initializr: Create a Maven Project
```
Specify a Spring Boot version, select 3.0
Specify a project language Java
Input group id for your project com.example, it will scaffold up a directory structure for you as well as adding this id in the pom.xml file.
Input Artifact Id for your project Demo
Specify packaging type Jar, you can change this later to War if you want (if you want to run your app in application server like Tomcat for example, you want a War file but for now the app will run in a built-in server)
Specify Java version
Search for dependencies, you want to add Spring Web at minimum, but might want to add other dependencies in the future like JPA, Session management and more.

Your project so far

This scaffolded a project for you. Let's go through the parts you need to know about:

src/
  main/
    java/
      com/
        example/
          demo/
            DemoApplication.java
    resources/
      application.properties 
  test/

As you can see above, you have structure consisting of application files, DemoApplication.java under demo/, configuration files under resoruces/ and tests under test/.

Application files

So far, you only have one application file DemoApplication.java which looks like so:

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Demo2Application {

    public static void main(String[] args) {
        SpringApplication.run(Demo2Application.class, args);
    }

}

This file is the entry point to your application.

Configuration

You have a configuration file application.properties that starting out is empty but will be used as you add things to your app in need of configuring for example:

what port to start up on.
if you got self documenting docs like Swagger.
credentials for a database, if you're using one.

What are routes?

In a Web API there are logical areas of your application like customers, orders, products and so on. When you have the user use your app you can send the user to these logical areas by specifying routes, parts of the URL. Imagine that you have the following URL http://contoso.com and you have three areas in your app:

customers, this is where you handle customers, adding new ones and updating existing ones.
products, these are products the customers can buy.
orders, these are orders the customers can place.

based on these areas, we can now create areas of our app addressing them like so:

/customers
/products
orders

so when a user then navigates to for example /customers they would type in the full address http://www.contoso.com/customers but the route part would be /customers a sub part of the URL.

We can now write code that responds to a route like the ones mentioned above.

Adding a route

To add a route, you need to create a class like so:

@RestController
public class HelloServiceController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public ResponseEntity<Object> getHello() {
       return new ResponseEntity<>("hello", HttpStatus.OK);
    }
}

Let's break down what's going on:

The decorator @RestController ensures the class can respond to web request.
@RequestMapping(value = "/hello", method = RequestMethod.GET) does two things, response to a specific route "/hello" and to a specific HTTP verb, GET, which means to read data from the server.
The method getHello() produces a response of type ResponseEntity<Object> and the specific call we make, return new ResponseEntity<>("hello", HttpStatus.OK) produces a text response with code 200, HttpStatus.OK which means everything is ok.

Now that we know how we can create code to respond to route requests, let's add code to handle /products route in the below exercise.

Exercise: adding a route

Create a product directory in the same place as your DemoApplication.java file and create the following files:

   Product.java
   ProductController.java
   ProductRepository.java

Give Product.java the following content:

   package com.example.demo.product;

    public class Product 
    {
        private String name;

        public Product(String name) 
        {
            this.name = name;
        }

        public String getName() 
        {
            return this.name;
        }
    }

the Product class will serve as our model.

Give ProductRepository.java the following content:

   package com.example.demo.product;

    import java.util.ArrayList;

    public class ProductRepository 
    {
      private ArrayList<Product> products;

      public ProductRepository() 
      {
        this.products = new ArrayList<Product>();
        this.products.add(new Product("tomato")); 
      }
      public ArrayList<Product> getProducts() 
      {
        return this.products;
      }
    }

ProductRepository will now have one entry of type Product.

Give ProductController.java the following content:

    package com.example.demo.product;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;

    import java.util.ArrayList;

    @RestController
    public class ProductController {
        /**
         * @return
         */
        // TODO: query param, route param
        @RequestMapping(value = "/products")
        public ResponseEntity<ArrayList<Product>> getProducts() {
           ProductRepository repo = new ProductRepository(); 
           return new ResponseEntity<>(repo.getProducts(), HttpStatus.OK);
        }
    }

Now we have all the code needed to respond to a web request to /products. Next, let's run our app:

Select "Spring Boot dashboard" icon on the left menu in Visual Studio Code, should look like a stop icon.
Select the play icon to start your app
In your browser, navigate to "http://localhost:8080/products", you should see the following output:

   http://localhost:8080/products

Document your API via Open API (Swagger)

Next, we want to learn how to document our API. We can use Open API to do so (formerly known as Swagger). In our pom.xml file, the file Maven uses to keep track of dependencies, we can add the following dependency:

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.0.0</version>
</dependency>

this will ensure our Maven project knows how to add the capability that will give us Open API support.

On the command line, you can now type:

mvn package

which will fetch all dependencies (if not fetched already) and add package your project into a Jar file.

Open API

This dependency will do two things for us:

Create an Open API specification, a JSON file that describes our API, that can be used to create a connector for Microsoft Power Platform for example or in other ways help describe how to work with our API.
Create a a UI that we can interact with to test our interface.

Exercise: add Open API

Add the following XML to the dependencies section of your pom.xml:

   <dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.0.0</version>
   </dependency>

Run mvn package in the command line
In resources directory, locate application.properties and add the following content:

   springdoc.api-docs.path=/docs
   springdoc.swagger-ui.path=/swagger.html

this will ensure we can find our Open API spec file at /docs and our UI at swagger.html

Start the app again via the Spring boot dashboard icon in Visual Studio Code:
Navigate to "http://localhost:8080/docs", you should see a JSON output similar to below, i.e our specification file:

   {"openapi":"3.0.1",
    "info":{"title":"OpenAPI definition","version":"v0"},"servers":[
      { "url":"http://localhost:8080",
        "description":"Generated server url"}],
        "paths":{
          "/hello":{"get":{
          "tags":["hello-service-controller"],"operationId":"getHello",
          "responses":{
            "200":{
              "description":"OK",
              "content":{
                "*/*":{"schema":{"type":"object"}}}}}
         }},
         "/products":{
                  "get":{"tags":["product-controller"],    "operationId":"getProducts",
                  "responses":{"200":{"description":"OK","content":{"*/*":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Product"}}}}}}},
                  "put":{"tags":["product-controller"],"operationId":"getProducts_3",
                  "responses":{"200":{"description":"OK","content":{"*/*":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Product"}}}}}}},
                  "post":{"tags":["product-controller"],"operationId":"getProducts_2",
                  "responses":{"200":{"description":"OK","content":{"*/*":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Product"}}}}}}},
                  "delete":{"tags":["product-controller"],"operationId":"getProducts_5",
                  "responses":{"200":{"description":"OK","content":{"*/*":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Product"}}}}}}},
                  "options":{"tags":["product-controller"],"operationId":"getProducts_6",
                  "responses":{"200":{"description":"OK","content":{"*/*":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Product"}}}}}}},
                  "head":{"tags":["product-controller"],"operationId":"getProducts_1",
                  "responses":{"200":{"description":"OK","content":{"*/*":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Product"}}}}}}},
                  "patch":{"tags":["product-controller"],"operationId":"getProducts_4",
                  "responses":{"200":{"description":"OK","content":{"*/*":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/Product"}}}}}}}}},
                  "components":{"schemas":{"Product":{"type":"object","properties":{"name":{"type":"string"}}}}}}

Navigate to http://localhost:8080/swagger.html this will present you with a graphical view, where you can try out your API.

Congrats, you've managed to build a Web API support the route /products but you also managed to document it using Open API. You are know well setup do extend it further and add data source to it with for example JPA (Java Persistence API), which we will cover in our next article.

Go from the beginning - arrays and slices

Chris Noring — Tue, 27 Sep 2022 16:41:52 +0000

An array is group of elements that are connected. You want to use an array when you have a group of something, like many orders, cars, rows in a file. The idea is to collect all that data in one structure. You also want to be able to iterate over it and possibly carry out an operation on it as a group.

Series

Your first program, you are here
Variables
If and else
Conversions
Loops
User input
Functions
Error handling
Arrays, you are here

Declare an array

To declare an array, you need to specify the following properties:

capacity, how many elements it holds.
type, what type of elements it holds.
array content, you can assign it elements at creation or do so later.

Here's the syntax:

[<capacity>]<type>{...element}

It starts with the square brackets, []. Within the square brackets you set the capacity, how many elements it can hold.

and here's a more real example:

cities := [5]string{"NY", "LA"}

In the preceding code, an array of strings is declared. It has capacity for 5 elements and two of the places are filled with "NY" and "LA". Note also because we set the capacity to 5 and the number of elements it's assigned is 2, there's 3 spaces free.

Capacity by inference

You don't have to set capacity to an explicit number, you can set it to ..., in which case the capacity will be set to the number of elements you assign to it, like so:

ids := [...]int{1, 2, 3, 4}

The preceding code has 4 elements, and that's also its capacity.

Accessing elements

The way to access an element is by using its index. Index is 0 based, meaning the first index is 0 and its last is the length -1.

ids := [...]int{1, 2, 3, 4}
ids[0] // 1
ids[3] // 4

Length and capacity

Imagine we have the following array declared:

cities := [5]string{"NY", "LA"}

length. The length is defined as the number of elements in the array. You can use the len() method to find this out:

   len(cities) // 2

capacity. The capacity is how many elements the array can hold. cap() is the method you use to find the capacity:

   cap(cities) // 5

Slices

A slice is a part of an array. A slice is created when the slice operator is being used. Here's the syntax for the slice operator:

s[i:p]

s, the array
i, the first index of the array to take elements from
p, The variable p corresponds to the last element in the underlying array that can be used in the new slice. I.e cut right before this index.

items := [5]int{1,2,3,4,5}
part = items[1:3] // 2,3

Adding elements

A slice differs from an array, you can add items to it. The append() method lets you add elements to it. The syntax for append() is as follows:

append(slice, element)

Here's how you can append to a slice:

var numbers []int
numbers = append(numbers, 1)
numbers = append(numbers, 2) // 1,2

Removing elements

Remove an element by constructing a new slice.

letters := []string{"A", "B", "C", "D", "E"}
remove := 2 // remove index
// 0 - remove index, remove +1 to end   
letters = append(letters[:remove], letters[remove+1:]...)

Create a slice with make

You can use the make() method to create a slice. Here's how:

slice := make([]int, 5) // creates a slice with length 5 and capacity 5

You can set these to different values:

slice2 := make([]int, 2, 5)
fmt.Println(slice2)
fmt.Println(len(slice2))
fmt.Println(cap(slice2))

Here, the slice has length 2 and capacity 5.

Copy elements

arr := [3]int{1, 2, 3}
dest := make([]int, 5)
copy(dest, arr[0:2]) // copies slice {1,2} into dest
fmt.Println(dest) // [1 2 0 0 0]

Summary

In summary, you were taught how to use Arrays. Additionally, we covered working with slices. Slices allows you to work with an array like structure and change its size as you see fit.

Learn more

https://docs.microsoft.com/en-us/learn/modules/go-data-types/2-slices

How YOU can deploy your resume in 2 min using Azure Static Web apps

Chris Noring — Tue, 20 Sep 2022 15:54:26 +0000

TLDR; In this post, you'll deploy your resume to the cloud using Visual Studio Code and Azure Static Web Apps.

Resources

Creating your resume

Writing a resume is an important activity in landing your first job as a student. It's also important later in life for those times you're looking to grow in your career.

Azure Static Web apps

Azure Static Web Apps is an Azure service that lets you deploy simpler static sites as well as web apps built in a SPA framework. It even lets you add an API to build a fullstack app.

In short, there's a great grow up story.

Tools for deployment and app lifecycle

Azure Static Web apps lets you deploy using more than one way, you can use of any of the following approaches:

How it works

Azure Static Web apps does more for you than just deployment. In fact, it handles the complete app dev lifecycle. The first time you deploy, it creates a CI/CD pipeline so that any future changes, you only need to focus on pushing commits to GitHub. The rest, to redeploy, is all taken care of by a .yml file created in a .github directory in you repo. High-level, here's what's going on:

Deploy the first time

Project deployed.
.yml file created in repo creating a CI/CD pipeline.
GitHub actions deploying everything using the .yml file above.

Future changes

You push commits to your repo
Everything is built and deployed using GH actions and your .yml file.

Deploy your resume

To deploy our resume, we need the following software installed.

Prerequisites

To deploy our resume, we need the following:

A GitHub account and we need to be logged in.
Visual Studio Code installed.
Azure Static Web Apps and VS Code extension installed.

Deployment

In this deployment, you can definitely create your own resume and repo or create one from this template.

If you start with static files (not from a GH repo), you will get some questions below regarding Git.

Type (Command + P or Control P) to open the command palette.
Type "Azure Static Web Apps: Create Static Web App" to start the deployment process.
Select your subscription
Select "Create" when asked to create a Git repo as well as GH repo (if you start with only static files, if you start from a repo, you won't get this question)
Enter a commit message, you can select what it proposes, i.e "Initial commit"
Enter name of static web app
Enter name of GH repository (it will be created for you)
Select a region
Select "Custom" as preset
Enter location of application /
Enter location of build output, clear this field.

From here, it should be deploying your project - Congrats, your resume is online

Summary

You learned how you can deploy your resume in minutes using Azure Static Web Apps and Visual Studio Code.

How YOU can build your own test framework in Python using decorators

Chris Noring — Wed, 31 Aug 2022 14:33:36 +0000

TLDR; this article will show how decorators work, some uses for decorators and a bigger example building the start of test framework. It's ~15 min long BUT, there's a very cool project at the end of it - learning how to build your own test framework :)

So, decorators, what are those, and why would I use them? You might have seen something like this before in your Python code @debug or @log right above your function signature like so:



@log
def method():
  pass

Running your method, you might have gotten out some useful information about the method(). If you haven't seen this, that's fine, let me take you on a journey.

References

Decorators

The @ character denotes something we call decorators; the idea is to decorate a function without the function being aware. It can add capabilities to the function like:

execution time, how long it takes the function to run from start to finish.
debugging, information on function name, parameters.

Let's look at a case where we decorate a function:



def decorator(fn):
  print("BEFORE")
  fn()
  print("AFTER")

def log():
  print("[LOG]")

decorator(log)

Running this function results in the following output:



BEFORE
[LOG]
AFTER

Python decorators

Python has a specific way of handling decorators, so much so it lets you use a shorthand @. But first, let's tweak the above code so that it's a good candidate to using the shorthand. Change the code to the following:



def decorator(fn):
  def wrapper()
    print("BEFORE")
    fn()
    print("AFTER")
  return wrapper

def log():
  print("[LOG]")

fn = decorator(log)

What we did was to create an inner function wrapper() in decorator() function and return it. Also, when invoking decorator(), we save the response to fn and invoke that:



fn = decorator(log)

Here's the beautiful part, Python lets us turn the above code:



def log():
  print("[LOG]")

fn = decorator(log)

and turn it into the following:



@decorator
def log():
  print("[LOG]")

log()

Note above how @decorator have replaced the call to decorator() and @decorator is now above the definition of log().

Pause here for a moment and take this in. This is a great start!

Parameters

OK, so great progress so far, we can write decorators, but what happens if we want to use parameters on functions being decorated? Well, let's see what happens:



@decorator
def add(lhs, rhs):
  return lhs + rhs

add(1,1)

You get an error:



TypeError: wrapper() takes 0 positional arguments but 2 were given

So, we're not handling incoming parameters, how to fix?

Well, when you call a function, there are two parameters that Python works with under the hood:

*args, a list of parameter values.
**kwargs, a list of tuples where each tuple is the name and value of your parameter.

You can fix the above issue if you send these via your wrapper function into the function being decorated like so:



def wrapper(*args, **kwargs):
    fn(*args, **kwargs)
  return wrapper

Running the code again, it compiles this time, but the output says None, so there seems to be some other problem, where we lose the return value of our decorated function.

How can we solve that?

What we need to do is to ensure the wrapper() function captures the return value from the function being decorated and return that in turn, like so:



def wrapper(*args, **kwargs):
    ret = fn(*args, **kwargs)
    return ret
  return wrapper

Great, so we learned a little more about dealing with parameters and return values with decorators. Let's learn next how we can find out more about the function we decorate.

Instrumentation

We're building up our knowledge steadily so we're able to use it to build a bigger project at the end of the article. Now let's look at how we can find out more about the function we decorate. In Python, you can inspect and find out more about a function by using the help() method. If you only want to find out a functions' name, you can refer to __name__ property like so:



def log():
  print("[LOG]")

print(log.__name__) # prints log

How does this work in a decorator, is there a difference?

Let's try it by adding it to the decorator:



def decorator(fn):
  def wrapper(*args, **kwargs):
    print("calling function: ", fn.__name__)
    ret = fn(*args, **kwargs)
    return ret
  return wrapper

@decorator
def add(lhs, rhs):
  return lhs + rhs

print(add.__name__)
print(add(1,1))

Calling the above code, we get the following output:



wrapper
calling function:  add
2

It seems, add() within the decorator is rightly referred to as add. However, outside of the decorator calling add.__name__, it goes by wrapper, it seems confused, no?

We can fix this using a library called functools that will preserve the function's information like so:



@functools.wraps(fn)

and our full code now looks like:



import functools

def decorator(fn):
  @functools.wraps(fn)
  def wrapper(*args, **kwargs):
    print("calling function: ", fn.__name__)
    ret = fn(*args, **kwargs)
    return ret
  return wrapper

@decorator
def add(lhs, rhs):
  return lhs + rhs

print(add.__name__)
print(add(1,1))

Running this code, we see that it's no longer confused and the add() function is referred to as add in both places.

Ok, we know enough about decorators at this point to be dangerous, let's build something fun, a test framework.

Assignment - build a test framework

DISCLAIMER: I should say there are many test frameworks out there for Python. This is an attempt to put you decoration skills into work, not to add to an existing pile of excellent frameworks, however, you're free to hack away at this project if you find it useful :)

-1- How should it work

Ok, let's start with how it should work, that will drive the architecture and the design.

We want to have the following experience as developers writing tests:

I just want to add a @test decorator.
I want to call some type of assertion in my test methods.
I want to do max one function call to run all tests.
I want to see tests that succeed and fail, and I want extra info about the failing test so I can correct it
Nice to have, please add color to the terminal output.

Based on the above, my test file should look something like this:



@test
def testAddShouldSucceed():
  lhs = 1
  rhs = 1
  expected = 2
  expect(add(lhs,rhs), expected, "{lhs} + {rhs} should be equal to {sum}".format(lhs = lhs, rhs = rhs,sum = expected))

@test
def testAddShouldSucceed2():
  lhs = -1
  rhs = 1
  expected = 0
  expect(add(lhs,rhs), expected, "{lhs} + {rhs} should be equal to {sum}".format(lhs = lhs, rhs = rhs,sum = expected))

if __name__ == "__main__":
  run()

-2- Building the parts, `decorator()`, `expect()`

Ok, based on the previous part, we need three things:

@test, a decorator.
expect() a method that checks if two values are equal.
run() a method running all functions decorated with @test.

Let's get to work.

Create a file decorator.py and give it the following content:



   def test(fn):
      @functools.wraps(fn)
      def wrapper(*args, **kwargs):
        try:
          fn(*args,**kwargs)
          print(". PASS") 
        except TestError as te:
          print(f"{fn.__name__} FAILED with message: '{te.mess}'")
        # fns.append(wrapper)
      return wrapper

The above decorator test() will run test method and print . PASS if the method runs without error. However, if TestError is thrown, you will see FAILED with message . How can a test method crash? Let's implement expect() next.

Create a file expect.py and give it the following code:



   from util import TestError

   def expect(lhs, rhs, mess):
     if(lhs == rhs):
       return True
     else:
       raise TestError(mess)

Ok, so return true if all good, and crash if not, got it!. What is TestError?

Create a file util.py and give it the following code:



   class TestError(Exception):
     def __init__(self, mess):
       self.mess = mess

Above we're inheriting from Exception and we'e adding a field mess that we store any error message in.

Let's revisit decorator.py. Look at the following codeline:



   def test(fn):
      @functools.wraps(fn)
      def wrapper(*args, **kwargs):
        try:
          fn(*args,**kwargs)
          print(". PASS") 
        except TestError as te:
          print(f"{fn.__name__} FAILED with message: '{te.mess}'")
        # fns.append(wrapper)
      return wrapper

Enable the commented out line # fns.append(wrapper). What this line does is to add each test function to a list. We can use that when we implement the run() function. Add run() to the bottom of the file with this code:



   def run():
     for fn in fns:
       fn()

Great, now we just have one thing missing, some colors :)

-3- Give it color

To give it colors let's install a library coloroma.

Create a virtual environment



   python3 -m venv test-env

Activate the virtual environment



   source test-env/bin/activate

Install colorama



   pip install colorama

Adjust decorator.py and ensure the code looks like so:



   import functools

   from colorama import Fore
   from colorama import Style
   from util import TestError

   fns = []

   def test(fn):
     @functools.wraps(fn)
       def wrapper(*args, **kwargs):
         try:
           fn(*args,**kwargs)
           print(f"{Fore.GREEN}. PASS{Style.RESET_ALL}")
         except TestError as te:
           print(f"{Fore.RED}{fn.**name**} FAILED with message: '{te.mess}' {Style.RESET_ALL}")
       fns.append(wrapper)
       return wrapper

    def run():
      for fn in fns:
        fn()

Create a file demo.py and give it the following content:



   from decorator import test, run
   from expect import expect

   def add(lhs, rhs):
     return lhs + rhs

   @test
   def testAddShouldSucceed():
     lhs = 1
     rhs = 1
     expected = 2
     expect(add(lhs,rhs), expected, "{lhs} + {rhs} should be equal to {sum}".format(lhs = lhs, rhs = rhs,sum = expected))

   @test
   def testAddShouldSucceed2():
     lhs = -1
     rhs = 1
     expected = 0
     expect(add(lhs,rhs), expected, "{lhs} + {rhs} should be equal to {sum}".format(lhs = lhs, rhs = rhs,sum = expected))

   @test
   def testAddShouldFail():
     lhs = 1
     rhs = 2
     expected = 4
     expect(add(lhs,rhs), expected, "{lhs} + {rhs} should be equal to {sum}".format(lhs = lhs, rhs = rhs,sum = expected))

   if **name** == "**main**":
     run()

-4- Demo time

Run the program



   python demo.py

Congrats, you've built your first test framework.

Ideas for improvement

So, what's next?

Well, the expect() method is limited in what it can compare, see if you can build other functions capable of comparing lists, objects and so on. Also, how would you test if a method throws a specific exception?

Summary

You've learned about decorators and their use cases. You've also built something useful with them - a test framework. Try it out, change it to your liking. Also, I would recommend reading this excellent post as well, https://realpython.com/primer-on-python-decorators/

How YOU can build your first Low code app using Microsoft Power Platform

Chris Noring — Mon, 08 Aug 2022 13:34:32 +0000

TLDR; in this article, you will learn how to build your first Low Code application using Power platform.

You will learn:

Lay out controls for displaying and capturing data.
Respond to events.
Save state in a variable.

References

What is Low code and why do we care?

Low code development is using blocks instead of specific code to build apps and services. There are many Low Code platforms, Microsoft's is called Microsoft Power Platform.

The reason these platforms exist is that there's a great need to build business apps and not enough developers to build them. Also, many times non developer sit on business expertise, and it takes time to convey all they know to developers.

With a low code platform, you can empower these business experts and turn them into citizen developers, and have them build apps.

Canvas app

There are many types of low code apps you can build with Microsoft Power Platform. Canvas apps lets you build traditional apps in many ways.

You can either build everything from scratch or model driven from a data source like for example Dataverse.

The idea is that you design an app much like a Powerpoint slide and use Excel like expressions to add logic.

DEMO - build your first app

Navigate to https://make.powerapps.com
Select "+ Create", to create a canvas app.
Select "Blank app", in the main area on your right.
Give it an app name and select Tablet.
Select + in the left menu to add controls.
Select a Text label and drag it onto the screen.
Select the control and change the Text property, either in the control or via the dropdown like so:

Select a button and drag it onto the screen. Change its value to "Save".
Select the button and ensure the OnSelect property is selected.
Change the fx value to UpdateContext({ myvar: "clicked" }), this will create a variable myvar and give it the value "clicked":

Select your label and change its content, in the fx area, to the following "Show text:" & myvar, this will ensure it shows the content of a static text and the value of myvar.

The & concatenates two strings together.

Test your program by clicking the play icon on the top right side:

Try clicking the button and ensure it says "clicked".

Nicely done, you've created your first Canvas app, but we can improve it a little by relying on text inputs.

Use a text field

Drag a Text input out onto the main surface.
Note the name of the Text Input, you will refer to it now in the OnSelect property of the button:

Change the OnSelect fx value of the button to the following code

   UpdateContext({ myvar: TextInput2.Text })

The above code will set myvar to the content of the TextInput2 control and its Text property.

Run your program:
1. Enter some text, for example "abc" in the text field
2. Click the button, you should now see the label be updated accordingly to "Show text: abc", it's working.

Let's improve our program next by clearing the input field after we click a button.

Clear input fields

Select the button and add the following code in the fx area:

   Reset(TextInput2)

Your full code in OnSelect should look like so:

   UpdateContext({ myvar: TextInput2.Text });

   Reset(TextInput2);

Drag the fx field down vertically to see more of it. Note how we added semicolons, ; above to separate between multiple statements.

this code will clear the text input field and reset it to its default value.

You were show one way so far to clear a text input, there's another way, lets do that next.

Select the text input field and find a property in the control detail on the right called "Clear button" and enable it, like so:

Run the program and notice the "X" that appears in the text field. This "X" will let you clear the text field via the UI.

Congratulations, you've taken your first steps to using controls and understand how they work.

Interview problem - FizzBuzz

Chris Noring — Wed, 06 Jul 2022 21:35:00 +0000

So, you try to pass an interview as a programmer. There are a few ways you're tested, it's not just coding skills but your ability to communicate.

Communicate, what do you mean, code either compiles and works or it don't?

Well, no, so you live in a world with stakeholder and team members. In that world, you need to navigate and that means understanding a problem, asking clarifying questions and be prepared for changes and yes sometimes short deadlines.

So what can I expect on the interview then?

Well, for one, a problem, and not just a problem, you're expected to communicate from start to finish, through all the phases.

What phases?

Understand the problem

In this phase, you need to listen, repeat back what you heard and from there communicate assumptions. If those assumptions are incorrect, you may get clarifications. What you don't want to do is to just code away thinking you understood everything.

Problem breakdown

In this phase, you should start to think about how to break down a problem in easier parts, sub problems if you will. At the job, you will be given big and complicated tasks and you will be asked to break it down into smaller parts that you can solve. - That's the job, oh and coding :).

Start coding

At this point, start implementing the easier parts of your problem, a naive solution if you will. See if your interviewer has any comments. Then proceed until you have a working solution.

Cover all your bases

At this point, ensure you communicate any edge cases that you might need to handle and possible improvements to your code.

Here it's likely your interviewer may spot a bug or ask you to implement a new requirement. Don't panic, take your time and figure out how to solve.

Summary

In the last part, the interviewer may sum up the interview and ask general questions, but if you have communicated thus far, you've written reasonable code that mostly works, chances are you pass this interview.

So what problem am I likely to get, can you give m an example?

The problem : Fizz Buzz

Lets take a problem called Fizz Buzz. Here's the description:

Your code is divisible by 5 and 3. If both then print "FizzBuzz", if only by 3, then "Fizz" if only by 5, then "Buzz".

To approach this problem, ensure you understand its sub problems:

1) Divisible, that a number is divided and leaves no remainder and you at least in Python have a module operator to help you.
2) Understand what condition to implement first, i.e. you should start with divisible by 5 and 3 and then add the other conditions.

Here's a solution:

arr = range(30)
for item in arr:
  no = item + 1
  if no % 5 == 0 and no % 3 == 0:
    print(f"{no} FizzBuzz")
  elif no % 5 == 0:
    print(f"{no}: Buzz")
  elif no %3 == 0:
    print(f"{no} Fizz")
  else:
    print(f"{no}")

and yea, take your time implementing and COMMUNICATE cause you're tested on both skills.

Go from the beginning - handle errors

Chris Noring — Tue, 05 Jul 2022 14:46:26 +0000

Subscribe

Our apps aren't perfect, they will throw errors. Either they throw errors because of code we wrote or because of code written in a package we are using. Sometimes, that's even what the code is supposed to do when we feed it bad input.

Regardless, our users expect us to handle these errors. Also, for our own sake, we need to log these errors in such a way that we can fix those errors, if they are unexpected.

There are two major ways to handle errors in Go:

panic/recover. panic and recover are language constructs. If you know anther programming language, they function pretty much like throw and catch. What does it mean though? It means there's an error, with an error message and stack trace that we can catch and recover from or let it crash the program.
error pattern. This is referred to as the idiomatic Go way of doing things. The idea is to return a value and an error object from a function call. If an error occurred, it contains an error object or nil, if no error.

Series

Your first program, you are here
Variables
If and else
Conversions
Loops
User input
Functions
Error handling, you are here

Crash the program with `panic()`

Let's take this function Divide():

func Divide(nominator int, divider int) float32 {
 if divider == 0 {
  panic("can't divide by 0")
 }
 return float32(nominator) / float32(divider)
}

It has an if check. If Divider() is 0 then it calls panic(). So what happens then? You see something similar to:

panic: can't divide by 0

goroutine 1 [running]:
main.Divide(...)
        /<path>/panic.go:20
main.main()
        /<path>/panic.go:33 +0x96
exit status 2

At the top is the error string you sent to panic(), the string "can't divide by 0". Then you have the stack trace, entries that indicate where the error started. Read it from the bottom, the error started on line 33 but what really did it happened at line 20, which is this row:

panic("can't divide by 0")

Ok, so we have a way to protect ourselves from input values that we don't want. But crashing the program, is that really necessary? In some cases, it is, in some cases it isn't. For the latter cases we have recover().

Capture the error with `recover()`

Using recover() is about capturing an error so our program can continue. We need to learn about a concept though before proceeding. That concept is defer. defer is a language construct that delays the execution of a function until the nearby function returns. Here's an example:

defer fmt.Println("second")
fmt.Println("first")

Running this program, you should see:

first
second

See defer as the last thing that happens.

How is this useful in the context of capturing an error? Capturing errors, if you want to capture it, is something you want to do as the last thing that happens. Take our Divide() function again:

func Divide(nominator int, divider int) float32 {
 defer errorHandler()
 if divider == 0 {
  panic("can't divide by 0")
 }
 return float32(nominator) / float32(divider)
}

Note how it now has a line in it that says defer errorHandler(). It will be run the last thing that happens. Depending on the value of divider, it will either call panic() or call the return statement as the last thing.

Ok, so what does errorHandler() look like?

func errorHandler() {
 if r := recover(); r != nil {
  fmt.Println("Recovered ", r)
 }
}

In errorHandler(), we invoke recover() and assign it to variable r and then we test it for nil. If it's NOT nilthen we have an error and we print it out. If it is nil then the user notices nothing.

Exercise - add error handling

In this exercise, we'll add error handling to our program.

Create a file panic.go and give it the following content:

     package main

    import (
     "fmt"
    )

    // func errorHandler() {
    // if r := recover(); r != nil {
    //  fmt.Println("Recovered ", r)
    // }
    // }

    func Divide(nominator int, divider int) float32 {
     // defer errorHandler()
     if divider == 0 {
      panic("can't divide by 0")
     }
     return float32(nominator) / float32(divider)
    }

    func main() {
     no := Divide(10, 0)
     fmt.Println(no)
     no = Divide(10, 1)
     fmt.Println(no)
    }

Run the program go run panic.go

   go run panic.go

You should see output similar to:

   panic: can't divide by 0

    goroutine 1 [running]:
    main.Divide(...)
            /<path>/panic.go:20
    main.main()
            /path/panic.go:33 +0x96
    exit status 2

Note how these two statements was never run as the program crashed:

   no = Divide(10, 1)
   fmt.Println(no)

Uncomment the commented out part and run the app again.

You should now see following output:

   Recovered  can't divide by 0
   0
   10

Congrats, you've managed to implement error handling with panic() and recover().

Improve the error handling

There are steps we can take to improve the error handling. So far, we're printing back an error message. Imagine if someone read this error from a log file, would they be able to understand where things went wrong and possibly fix the input data or the code itself?

There are a couple of things we can do:

Inspect the error. Our error didn't only come with an error message, there's a stacktrace as well.
Logging. If we want someone to work with these errors, we should look at logging them to a file.

Inspect the error with `runtime/debug`

There's a library runtime/debug. With this library, you can find out more about an error when it's thrown, information like stacktrace, where the error originated. There's a function Stack() that produces the stacktrace. Here's how to use it:

debug.Stack()

Log the error with `log`

While runtime/debug is able to produce a stacktrace, what would be really useful is logging all this error information to a file. To log to a file, use the os and log package like so:

f, err := os.OpenFile("logs", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
 if err != nil {
  log.Println(err)
 }
 log.SetOutput(f)

Exercise - improve error logging

Let's improve our panic.go file by adding error logging:

Locate the errorHandler() and change it to the following:

   func errorHandler() {
     if r := recover(); r != nil {
       log.Println(r, string(debug.Stack()))
     }
   }

Ensure that panic.go looks like so:

    package main

    import (
     "fmt"
     "log"
     "os"
     "runtime/debug"
    )

    func errorHandler() {
     if r := recover(); r != nil {
      log.Println(r, string(debug.Stack()))
     }
    }

    func Divide(nominator int, divider int) float32 {
     defer errorHandler()
     if divider == 0 {
      panic("can't divide by 0")
     }
     return float32(nominator) / float32(divider)
    }

    func main() {
     f, err := os.OpenFile("logs", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
     if err != nil {
      log.Println(err)
     }
     log.SetOutput(f)

     log.Println("starting program")
     no := Divide(10, 0)
     fmt.Println(no)

     no = Divide(10, 1)
     fmt.Println(no)
     f.Close()
    }

Run this program:

   go run panic.go

You should see this output:

   0
   10

It was able to run all statements without being affected by the error that was thrown.

Inspect the logs file that was just created, it should have content similar to the below:

     2022/03/11 15:03:59 starting program

    2022/03/11 15:03:59 can't divide by 0 goroutine 1 [running]:
    runtime/debug.Stack(0xc000111d30, 0x10b1b40, 0x10eae78)
     /usr/local/Cellar/go/1.16/libexec/src/runtime/debug/stack.go:24 +0x9f
    main.errorHandler()
     /<path>/panic.go:14 +0x5b
    panic(0x10b1b40, 0x10eae78)
     /usr/local/Cellar/go/1.16/libexec/src/runtime/panic.go:965 +0x1b9
    main.Divide(0xa, 0x0, 0x0)
     /<path>/panic.go:21 +0xa5
    main.main()
     /<path>/panic.go:34 +0x115

Use the error pattern with the `errors` package

Other languages tend to use Exceptions to signal that something is wrong.

Go has a different and idiomatic approach. It wants you to create errors as return values to a function, next to the actual value being returned. You are then expected to inspect a function and see if it returns an error.

There's an errors package that can help us with the above approach.

Define an error

To define an error, we call the New() function with a string describing the error, here's an example:

var NoTooSmall = errors.New("the number is too small")

Next, let's look at how to add the error to a function.

Return an error

Let's start with function that uses a panic() as error handling:

func ReturnPositive(no int) int {
 if no > 0 {
  return no
 } else {
  panic("No too small")
 }

}

We can improve this function, by ensuring it returns the result and an error at all times, like so:

func ReturnPositive(no int) (int, error) {
 if no > 0 {
  return no, nil
 } else {
  return 0, NoTooSmall
 }

}

Note in the if clause that it returns no and nil when everything is fine. For the else, it returns a bogus value and our error NoTooSmall.

Inspect the result

Let's see how we would call the ReturnPositive() function and use this new pattern we established:

no, err := ReturnPositive(-2)
 if err != nil {
  fmt.Println("error: ", err)
 } else {
  fmt.Println("value:", no)
 }

What you are seeing above is how we use an if clause to check for errors, if so, print out. On the else, we have our actual value.

Summary

In this article, you saw how you could cause and handle errors with panic() and recover(). Another, more idiomatic approach i by using an error pattern, in which you return the result and an error. Then you need to inspect the result to see if an error was produced or if you can safely use the returned value.

Learn Docker - from the beginning, part I images and containers

Chris Noring — Mon, 04 Jul 2022 14:26:34 +0000

Follow me on Twitter, happy to take your suggestions on topics or improvements /Chris

Subscribe to my channel

This article is part of a series:

Docker — from the beginning part I, we are here.
Docker — from the beginning, Part II, this is about Volumes and how we can use volumes to persist data but also how we can turn our development environment into a Volume and make our development experience considerably better
Docker — from the beginning, Part III, this is about how to deal with Databases, putting them into containers and how to make containers talk to other containers using legacy linking but also the new standard through networks
Docker — from the beginning, Part IV, this is how we manage more than one service using Docker Compose ( this is 1/2 part on Docker Compose)
Docker - from the beginning, Part V, this part is the second and concluding part on Docker Compose where we cover Volumes, Environment Variables and working with Databases and Networks

Now there are a ton of articles out there for Docker but I struggle with the fact that none of them are really thorough and explains what goes on, or rather that’s my impression, feel free to disagree :). I should say I’m writing a lot of these articles for me and my own understanding and to have fun in the process :). I also hope that it can be useful for you as well.

So I decided to dig relatively deep so that you all hopefully might benefit. TLDR, this is the first part in a series of articles on Docker, this part explains the basics and the reason I think you should use Docker.

This article really is Docker from the beginning, I assume no pre-knowledge, I assume nothing. Enjoy :)

In this article, we will attempt to cover the following topics

Why Docker and what is it, this is probably the most important part of the article, why Docker, why not some other technology or status quo? I will attempt to explain what Docker is and what it consists of.
Docker in action, we will dockerize an application to showcase we understand and can use the core concepts that make out Docker.
Improving our set up, we should ensure our solution does not rely on static values. We can ensure this by creating and setting environment variables whose value we can read from inside of our application.
Managing our container, now it’s fairly easy to get a container up and running but let’s look how to manage it, after all, we don’t want the container to be up and running forever. Even it’s a very lightweight thing, it adds up and it can block ports that you want to use for other things.

Remember that this is the first part of a series and that we will look into other things in this series on Docker such as Volumes, Linking, Micro Services, and Orchestration, but that will be covered in future parts.

Resources

Using Docker and containerization is about breaking apart a monolith into microservices. Throughout this series, we will learn to master Docker and all its commands. Sooner or later you will want to take your containers to a production environment. That environment is usually the Cloud. When you feel you've got enough Docker experience have a look at these links to see how Docker can be used in the Cloud as well:

Sign up for a free Azure account To use containers in the Cloud like a private registry you will need a free Azure account
Containers in the Cloud Great overview page that shows what else there is to know about containers in the Cloud
Deploying your containers in the Cloud Tutorial that shows how easy it is to leverage your existing Docker skill and get your services running in the Cloud
Creating a container registry Your Docker images can be in Docker Hub but also in a Container Registry in the Cloud. Wouldn't it be great to store your images somewhere and be able to create a service from that Registry in a matter of minutes?

Why Docker and what is it

Docker helps you create a reproducible environment. You can specify the exact version of different libraries, different environment variables and their values among other things. Most importantly you can run your application in isolation inside of that environment.

The big question is why we would want that?

onboarding, every time you onboard a new developer in a project they need to set up a lot of things like installing SDKs, development tools, databases, add permissions and so on. This a process that can take from one day to up to 2 weeks
environments look the same, using Docker you can create a DEV, STAGING as well as PRODUCTION environment that all look the same. That is really great as before Docker/containerization you could have environments that were similar but there might have been small differences and when you discovered a bug you could spend a lot of time chasing down the root cause of the bug. Sometimes the bug was in the source code itself but sometimes it was due to some difference in the environment and that usually took a long time to determine.
works on my machine, this point is much like the above but because Docker creates these isolated containers, where you specify exactly what they should contain, you can also ship these containers to the customers and they will operate in the exact same way as they did on your development machine/s.

What is it

Ok, so we’ve mentioned some great reasons above why you should investigate Docker but let's dive more into what Docker is. We’ve established that it lets us specify an environment like the OS, how to find and run the apps and the variables you need, but what else is there to know about Docker?

Docker creates stand-alone packages called containers that contain everything that is needed for you to run your application. Each container gets its own CPU, memory and network resources and does not depend on a specific operating system or kernel. The first that comes to mind when I describe the above is a Virtual Machine, but Docker differs in how it shares or dedicates resources. Docker uses a so-called layered file system which enables the containers to share common parts and the end result is that containers are way less of resource-hog on the host system than a virtual machine.

In short, the Docker containers, contain everything you need to run an application, including the source code you wrote. Containers are also isolated and secure light-weight units on your system. This makes it easy to create multiple micro-services that are written in different programming languages and that are using different versions of the same lib and even the same OS.

If you are curious about how exactly Docker does this I urge to have a look at the following links on layered file system and the library runc and also this great wikipedia overview of Docker.

Docker in action

Ok, so we covered what Docker is and some benefits. We also understood that the thing that eventually runs my application is called a container. But how do we get there? Well, we start out with a description file, called a Dockerfile. In this Dockerfile, we specify everything we need in terms of OS, environment variables and how to get our application in there.

Now we will jump in at the deep end. We will build an app and Dockerize it, so we will have our app running inside of a container, isolated from the outside world but reachable on ports that we explicitly open up.

We will take the following steps:

create an application, we will create a Node.js Express application, which will act as a REST API.
create a Dockerfile, a text file that tells Docker how to build our application
build an image, the pre-step to having our application up and running is to first create a so-called Docker image
create a container, this is the final step in which we will see our app up and running, we will create a container from a Docker image

Creating our app

We will now create an Express Node.js project and it will consist of the following files:

app.js, this is the file that spins up our REST
package.json, this is the manifest file for the project, here we will see all the dependencies like express but we will also declare a script start so we can easily start our application
Dockerfile, this is a file we will create to tell Docker how to Dockerize our application

To generate our package.json we just place ourselves in the projects directory and type:

npm init -y

This will produce the package.json file with a bunch of default values.

Then we should add the dependencies we are about to use, which is the library express , we install it by typing like this:

npm install express —-save

Let’s add some code

Now when we have done all the prework with generating a package.json file and installing dependencies, it’s time to add the code needed for our application to run, so we add the following code to app.js:

// app.js
const express = require('express')

const app = express()

const port = 3000

app.get('/', (req, res) => res.send('Hello World!'))

app.listen(port, () => console.log(`Example app listening on port ${port}!`))

We can try and run this application by typing:

node app.js

Going to a web browser on http://localhost:3000 we should now see:

Ok so that works, good :)

One little comment though, we should take note of the fact that we are assigning the port to 3000 when we later create our Dockerfile.

Creating a Dockerfile

So the next step is creating our Dockerfile. Now, this file acts as a manifest but also as a build instruction file, how to get our app up and running. Ok, so what is needed to get the app up and running? We need to:

copy all app files into the docker container
install dependencies like express
open up a port, in the container that can be accessed from the outside
instruct, the container how to start our app

In a more complex application, we might need to do things like setting environment variables or set credentials for a database or run a database seed to populate the database and so on. For now, we only need the things we specified in our bullet list above. So let’s try to express that in our Dockerfile:

# Dockerfile

FROM node:latest

WORKDIR /app

COPY . .

RUN npm install

EXPOSE 3000

ENTRYPOINT ["node", "app.js"]

Let’s break the above commands down:

FROM, this is us selecting an OS image from Docker Hub. Docker Hub is a global repository that contains images that we can pull down locally. In our case we are choosing an image based on Ubuntu that has Node.js installed, it’s called node. We also specify that we want the latest version of it, by using the following tag :latest
WORKDIR, this simply means we set a working directory. This is a way to set up for what is to happen later, in the next command below
COPY, here we copy the files from the directory we are standing into the directory specified by our WORKDIR command
RUN, this runs a command in the terminal, in our case we are installing all the libraries we need to build our Node.js express application
EXPOSE, this means we are opening up a port, it is through this port that we communicate with our container
ENTRYPOINT, this is where we should state how we start up our application, the commands need to be specified as an array so the array [“node”, “app.js”] will be translated to the node app.js in the terminal

Quick overview

Ok, so now we have created all the files we need for our project and it should look like this:

-| app.js // our express app
-| Dockerfile // our instruction file that Docker will read from
-| node_modules/ // directory created when we run npm install
-| package.json // npm init created this
-| package-lock.json // created when we installed libraries from NPM

Building an image

There are two steps that need to be taken to have our application up and running inside of a container, those are:

creating an image, with the help of the Dockerfile and the command docker build we will create an image
start the container, now that we have an image from the action we took above we need to create a container

First things first, let’s create our image with the following command:

docker build -t chrisnoring/node:latest .

The above instruction creates an image. The . at the end is important as this instructs Docker and tells it where your Dockerfile is located, in this case, it is the directory you are standing in. If you don’t have the OS image, that we ask for in the FROM command, it will lead to it being pulled down from Docker Hub and then your specific image is being built.

Your terminal should look something like this:

What we see above is how the OS image node:latest is being pulled down from the Docker Hub and then each of our commands is being executed like WORKDIR, RUN and so on. Worth noting is how it says removing intermediate container after each step. Now, this is Docker being smart and caching all the different file layers after each command so it goes faster. In the end, we see successfully built which is our cue that everything was constructed successfully. Let’s have a look at our image with:

docker images

We have an image, success :)

Creating a container

Next step is to take our image and construct a container from it. A container is this isolated piece that runs our app inside of it. We build a container using docker run . The full command looks like this:

docker run chrisnoring/node

That’s not really good enough though as we need to map the internal port of the app to an external one, on the host machine. Remember this is an app that we want to reach through our browser. We do the mapping by using the flag -p like so:

-p [external port]:[internal port]

Now the full command now looks like this:

docker run -p 8000:3000 chrisnoring/node

Ok, running this command means we should be able to visit our container by going to http://localhost:8000, 8000 is our external port remember that maps to the internal port 3000. Let’s see, let’s open up a browser:

There we have it folks, a working container :D

Improving our set up with Environment Variables

Ok, so we’ve learned how to build our Docker image, we’ve learned how to run a container and thereby our app inside of it. However, we could be handling the part with PORT a bit nicer. Right now we need to keep track of the port we start the express server with, inside of our app.js , to make sure this matches what we write in the Dockerfile. It shouldn’t have to be that way, it’s just static and error-prone.

To fix it we could introduce an environment variable. This means that we need to do two things:

add an environment variable to the Dockerfile
read from the environment variable in app.js

Add an environment variable

For this we need to use the command ENV, like so:

ENV PORT=3000

Let’s add that to our Dockerfile so it now looks like so:

FROM node:latest

WORKDIR /app

COPY . .

ENV PORT=3000

RUN npm install

EXPOSE 3000

ENTRYPOINT ["node", "app.js"]

Let’s do one more change namely to update EXPOSE to use our variable, so we git rid of static values and rely on variables instead, like so:

FROM node:latest

WORKDIR /app

COPY . .

ENV PORT=3000

RUN npm install

EXPOSE $PORT

ENTRYPOINT ["node", "app.js"]

Note above how we change our EXPOSE command to $PORT, any variables we use needs to be prefixed with a $ character:

EXPOSE $PORT

Read the environment variable value in App.js

We can read values from environment variables in Node.js like so:

process.env.PORT

So let’s update our app.js code to this:

// app.js
const express = require('express')

const app = express()

const port = process.env.PORT

app.get('/', (req, res) => res.send('Hello World!'))

app.listen(port, () => console.log(`Example app listening on port ${port}!`))

NOTE, when we do a change in our app.js or our Dockerfile we need to rebuild our image. That means we need to run the docker build command again and prior to that we need to have torn down our container with docker stop and docker rm. More on that in the upcoming sections.

Managing our container

Ok, so you have just started your container with docker run and you notice that you can’t shut it off in the terminal. Panic sets in ;) At this point you can go to another terminal window and do the following:

docker ps

This will list all running containers, you will be able to see the containers name as well as its id. It should look something like this:

As you see above we have the column CONTAINER_ID or NAMES column, both these values will work to stop our container, cause that is what we need to do, like so:

docker stop f40

We opt for using CONTAINER_ID and the three first digits, we don’t need more. This will effectively stop our container.

Daemon mode

We can do like we did above and open a separate terminal tab but running it in Daemon mode is a better option. This means that we run the container in the background and all output from it will not be visible. To make this happen we simply add the flag -d . Let’s try that out:

What we get now is just the container id back, that’s all we’re ever going to see. Now it’s easier for us to just stop it if we want, by typing docker stop 268 , that’s the three first digits from the above id.

Interactive mode

Interactive mode is an interesting one, this allows us to step into a running container and list files, or add/remove files or just about anything we can do for example bash. For this, we need the command docker exec, like so:

Above we run the command:

docker exec -it 268 bash

NOTE, the container needs to be up and running. If you've stopped it previously you should start it with docker start 268. Replace 268 with whatever id you got when it was created when you typed docker run.

268 is the three first digits if our container and -it means interactive mode and our argument bash at the end means we will run a bash shell.

We also run the command ls, once we get the bash shell up and running so that means we can easily list what’s in the container so we can verify we built it correctly but it’s a good way to debug as well.

If we just want to run something on the container like a node command, for example, we can type:

docker exec 268 node app.js

that will run the command node app.js in the container

Docker kill vs Docker stop

So far, we have been using docker stop as way to stop the container. There is another way of stopping the container namely docker kill , so what is the difference?

docker stop, this sends the signal SIGTERM followed by SIGKILL after a grace period. In short, this is a way to bring down the container in a more graceful way meaning it gets to release resources and saving state.
docker kill, this sends SIGKILL right away. This means resource release or state save might not work as intended. In development, it doesn’t really matter which one of the two commands are being used but in a production scenario it probably wiser to rely on docker stop

Cleaning up

During the course of development you will end up creating tons of container so ensure you clean up by typing:

docker rm id-of-container

Summary

Ok, so we have explained Docker from the beginning. We’ve covered motivations for using it and the basic concepts. Furthermore, we’ve looked into how to Dockerize an app and in doing so covered some useful Docker commands. There is so much more to know about Docker like how to work with Databases, Volumes, how to link containers and why and how to spin up and manage multiple containers, also known as orchestration.

But this is a series of articles, we have to stop somewhere or this article will be very long. Stay tuned for the next part where we will talk about Volumes and Databases.

Acknowledgments

Thank you Dan Wahlin Twitter for your amazing course on Docker, a lot of things Docker clicked for me because of your course.

Follow me on Twitter, I’m happy to answer your queries and questions and suggestions for topics.

I've got a YouTube channel to complement my writing - what do you want to see?

Chris Noring — Wed, 29 Jun 2022 21:56:43 +0000

Hey friends. I decided to spend some time on building up a YouTube channel. I've been writing on dev.to for a while and a love it. I also recognize that some of you want to see videos additionally to written pieces.

This is what I'm working on at the moment on my channel and I would love some comments on what's there and what I can create.

Would really appreciate a subscribe as well.

Subscribe to my channel

Forem: Chris Noring

Getting started with GitHub Copilot part 2, streamable responses

Series on Copilot SDK

Addressing the problem

Links

Don't miss this opportunity to learn more about GitHub Copilot CLI

Get started with GitHub Copilot CLI: A free, hands-on course

Get started with GitHub Copilot SDK, part 1

Series on Copilot SDK

Install

The parts

Your first app

What's next

How YOU can build a Web API in Java and Spring boot

Build a Web API in Java and Spring boot

Further reading

Prereqs

Configure Visual Studio via extensions

Exercise: Create a Spring boot project

Your project so far

Application files

Configuration

What are routes?

Adding a route

Exercise: adding a route

Document your API via Open API (Swagger)

Open API

Exercise: add Open API

Go from the beginning - arrays and slices

Series

Declare an array

Capacity by inference

Accessing elements

Length and capacity

Slices

Adding elements

Removing elements

Create a slice with make

Copy elements

Summary

Learn more

How YOU can deploy your resume in 2 min using Azure Static Web apps

Resources

Creating your resume

Azure Static Web apps

Tools for deployment and app lifecycle

How it works

Deploy your resume

Prerequisites

Deployment

Summary

How YOU can build your own test framework in Python using decorators

References

Decorators

Python decorators

Parameters

Instrumentation

Assignment - build a test framework

-1- How should it work

-2- Building the parts, decorator(), expect()

-3- Give it color

-4- Demo time

Ideas for improvement

Summary

How YOU can build your first Low code app using Microsoft Power Platform

References

What is Low code and why do we care?

Canvas app

DEMO - build your first app

Use a text field

Clear input fields

Interview problem - FizzBuzz

Understand the problem

Problem breakdown

Start coding

Cover all your bases

Summary

The problem : Fizz Buzz

Go from the beginning - handle errors

Series

-2- Building the parts, `decorator()`, `expect()`

Crash the program with `panic()`

Capture the error with `recover()`

Inspect the error with `runtime/debug`

Log the error with `log`

Use the error pattern with the `errors` package