Managing Humans

It is a series of small chapters / stories of an experienced manager and has made a nice collection of personal learnings and battles and summed them up for our pleasure. Some chapters are hilarious so there will be some fun time involved.

You can expect a wide range of topics which will be about

• how to manage and live meetings
• how to interact with people, what are the agendas of people
• how to see and tackle corporate dramas
• and so much more

If you’re into management books take a peek. It’s definitely a good read.

tip: make sure you buy the last edition

The post Managing Humans first appeared on eltuko.net.

• the stage was never set for the meeting. Attendees are not aware what the scope of the meeting is. If You Fail to Plan, You Are Planning to Fail by Benjamin Franklin
• attendees were never trained to use focus, sometimes they are not aware this is one tool they can have in their tool belt (consciousness)
• there is little awareness of people on what a meeting actually is. Who are the actors in the room? What do they want? What is expected from the meeting. Who should be invited? And the list of questions goes on. (awareness)

With this article I wanted to share a learning I got from a former mentor of mine. He called this technique the fish model. Fancy naming .. very catchy :)

I will refer to a meeting now that is meant to take technical decisions. This meeting very probably will start with some problem to solve like: how the heck are we going to implement this feature?

So people will start discussing context on the feature, there will be questions of the attendees. This is the phase where attendees will gather information. So we will be a state of diverging. We are literally expanding our knowledge on the matter. It is clear at this point that the information grows and grows and that at some point this needs to stop. This is when a next phase will need to be explored the converge phase. See the picture to have a visual effect on this:

As you can see by gathering information you make room to have more choices available for your decision process. After that you will narrow down your choices that will translate into actions. Being conscious about this dynamic will help the attendees, because they know exactly when and what they should raise at any moment and help a natural and efficient flow of the meeting.

What the heck was the fish thingy about then? Well let me show it you with a different perspective:

At the beginning of meeting is the head of the fish. Information is low and alignment and information gathering is needed. The more into the meeting you move to the body of the fish. That is when we’ve a lot of information and choices on the table. Finally we arrive at just before the tail of the fish where we’ll decide and narrow down the choices. This is where you’ll have your action items to translate into concrete tasks. At this stage the meeting is over.

The tail is already the implementation phase, engineers will dig into deep technical knowledge for the implementation but at this phase the choice was already made and the engineer continues to implement and document the feature.

Take it with a grain of salt (fish tastes better with salt), it’s not a perfect technique but it surely helps meetings to go smoother if everybody is aware of the game.

The post The fish model for meettings first appeared on eltuko.net.

extra: https://sre.google/books/

The post What is SRE and how to bring it to the next level first appeared on eltuko.net.

Today I will do a presentation on how Leaseplan digital was able to introduce Datadog to monitor an application platform based on kubernetes.

This allowed the platform team to configure monitoring in such a way that the users of the platform do not need to do any extra configuration in order to have visibility over the applications that are running.

More info here

The post Datadog presentation first appeared on eltuko.net.

This book talks about how to design teams inside an organisation. This is a very important topic because of Conways law:

Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization’s communication structure.

— Melvin E. Conway

This means that when you design an architecture of a system or when you design a platform you better take into account the communication flows of the company and people involved. The team structure will be an imprint for your product architecture.

This book will give you options on how to structure teams. There are several ways defined in the book, ranging from a collaborative team to platform teams serving self service products. A must read before attempting to scale any teams or organisation!

More info on the team topologies website

The post Team topologies first appeared on eltuko.net.

First of all you’ve to pick your hardware and that’s where you’ve to do some choices. And my choice was to avoid buying a switch because I like it to have less cables and items lying around. Obviously not as reliable but it’s just a game.

Here you can see the difference. This is the only wifi version:

And here is the ethernet version:

So my focus on this post will be on how to make the Kubernetes work on a wifi only setup.

The first step would be to download raspbian you can find it here
You can pick the Raspbian Stretch Lite version.

Flash the micro-sd cards with the image, overwrite everything. Check it out how to do that here. For guys that have a windows machine you can use Win32DiskImager.

Now this will do the trick for the wifi setup:
In the boot disk of the flashed micro-sd card you have to add two files: ssh and wpa_supplicant.conf. ssh is empty and wpa_supplicant.conf must contain your wifi settings. (country code must be correct for your country)

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=NL

network={
    ssid="your-ssid-name"
    psk="your-password"
    key_mgmt=WPA-PSK
}

Then you can boot your raspberry and see if it comes up. You can use a tool like nmap in order to see it’s IP address. Please change the network range that corrisponds to your wifi network.

nmap -sn 192.168.0.0/24

This should produce a similar output:

Nmap scan report for 192.168.0.100
Host is up (0.079s latency).
MAC Address: <redacted> (Raspberry Pi Foundation)

Nmap scan report for 192.168.0.101
Host is up (0.019s latency).
MAC Address: <redacted> (Raspberry Pi Foundation)

Nmap scan report for 192.168.0.102
Host is up (0.094s latency).
MAC Address: <redacted> (Raspberry Pi Foundation)

Now you should be able to ssh in the host with this command:

ssh pi@192.168.0.100

The default password for raspbian is raspberry (you should change this later on)

This didn’t work for me the first time so I’ll give you some troubleshooting tips:

• If you don’t see the raspberry pi ip address with nmap, just connect a HDMI cable + monitor to your PI. Login with the usual credentials.
• Verify the config file called /etc/wpa_supplicant/wpa_supplicant.conf. Make sure that the file has no strange newlines or such.
• As an alternative you can do all of this with an interactive configuration tool: use sudo raspi-config to start it. Here you can also change the hostname or the network configuration of the pi.

Another step I advise you to do is setting a static ip address. You should edit the file /etc/dhcpcd.conf. Add these lines to each of your pi’s. Please mind that each of them might have different ip values according to your network.

interface wlan0
static ip_address=192.168.0.100/24
static routers=192.168.0.1
static domain_name_servers=192.168.0.1 8.8.8.8 fd51:42f8:caae:d92e::1

To apply the network settings just do a reboot this should then apply them correctly:

sudo reboot

Now your wifi, should be good at this point. Just continue the instructions on this well done blog post on how to install kubernetes on pi. No need for me to repeat the good work. Just mind the weave network setup step it has a typo in it. You can use this command instead:

kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"

So if all is good and your kubernetes is up an running let’s just do a final test to see if it works. Execute this command that will create a nginx deployment + service. First create this file nginx-deployment.yaml

apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2 # tells deployment to run 2 pods matching the template
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
---
kind: Service
apiVersion: v1
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Then apply the config with kubectl:

kubectl apply -f ./nginx-deployment.yaml

Verfiy your deployment:

pi@k8s-lord:~ $ kubectl describe deployment nginx-deployment
Name:                   nginx-deployment
Namespace:              default
CreationTimestamp:      Sun, 31 Mar 2019 11:27:58 +0100
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
                        kubectl.kubernetes.io/last-applied-configuration:
                          {"apiVersion":"apps/v1","kind":"Deployment","metadata":{"annotations":{},"name":"nginx-deployment","namespace":"default"},"spec":{"replica...
Selector:               app=nginx
Replicas:               2 desired | 2 updated | 2 total | 2 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=nginx
  Containers:
   nginx:
    Image:        nginx
    Port:         80/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Progressing    True    NewReplicaSetAvailable
  Available      True    MinimumReplicasAvailable
OldReplicaSets:  <none>
NewReplicaSet:   nginx-deployment-56db997f77 (2/2 replicas created)
Events:
  Type    Reason             Age   From                   Message
  ----    ------             ----  ----                   -------
  Normal  ScalingReplicaSet  3h1m  deployment-controller  Scaled up replica set nginx-deployment-56db997f77 to 2

Verfiy the service:

pi@k8s-lord:~ $ kubectl describe service nginx-service
Name:                     nginx-service
Namespace:                default
Labels:                   <none>
Annotations:              kubectl.kubernetes.io/last-applied-configuration:
                            {"apiVersion":"v1","kind":"Service","metadata":{"annotations":{},"name":"nginx-service","namespace":"default"},"spec":{"ports":[{"port":80...
Selector:                 app=nginx
Type:                     NodePort
IP:                       10.97.232.90
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  30681/TCP
Endpoints:                10.38.0.2:80,10.40.0.4:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

You can see it’s using the node port 30681 that is where I decided to host our service for the demo. Let’s try to navigate to
http://192.168.0.100:30681/ from our local network (same as wifi)

Here we go!

The post Raspberry K8s on Wifi first appeared on eltuko.net.

If you are on a DevOps transformation journey this is not doubt a good a read. It will give you the strength and some material to share with your coworkers.

The book remains quite high level (not too deep in the technologies) so it will give you an overview of DevOps practices and why they’re so powerful.
I would recommend the read to engineers but also to managers that want to understand or rollout DevOps practices to improve organisations.
This is also about creating a better workplace for you and your coworkers.

The post The DevOps Handbook first appeared on eltuko.net.

I explained how the choice of microservices architecture can give you a lot of advantages but it also brings along a lot of work as a trade off.

An example would be to configure a continuous integration pipeline for each of your services. A nice solution is to automate the creation of the pipelines. Check the slides if you are interested!

The post Micro Pipeline Hell first appeared on eltuko.net.

ARM deep dive by James Bannen

If you got some spare time and you are into Azure infrastructure automation I would highly recommend it to you :)
Thanks to James Bannen for creating this excellent course!

The post How to take your knowledge of Azure resource manager to the next level! first appeared on eltuko.net.

My desktop!

The post My desktop @ Work first appeared on eltuko.net.