Your instant Kubernetes cluster

https://blog.alexellis.io/your-instant-kubernetes-cluster

This is a condensed and updated version of my previous tutorial Kubernetes in 10 minutes. I've removed just about everything I can so this guide still makes sense. Use it when you want to create a cluster on the cloud or on-premises as fast as possible.

1.0 Pick a host

We will be using Ubuntu 16.04 for this guide so that you can copy/paste all the instructions. Here are several environments where I've tested this guide. Just pick where you want to run your hosts.

• DigitalOcean - developer cloud
• Civo - UK developer cloud
• Packet - bare metal cloud
• 2x Dell Intel i7 boxes - at home

Civo is a relatively new developer cloud and one thing that I really liked was how quickly they can bring up hosts - in about 25 seconds. I'm based in the UK so I also get very low latency.

1.1 Provision the machines

You can get away with a single host for testing but I'd recommend at least three so we have a single master and two worker nodes.
Here are some other guidelines:

• Pick dual-core hosts with ideally at least 2GB RAM
• If you can pick a custom username when provisioning the host then do that rather than root. For example Civo offers an option of ubuntu, civo or root.

Now run through the following steps on each machine. It should take you less than 5-10 minutes. If that's too slow for you then you can use my utility script kept in a Gist:

$ curl -sL https://gist.githubusercontent.com/alexellis/e8bbec45c75ea38da5547746c0ca4b0c/raw/23fc4cd13910eac646b13c4f8812bab3eeebab4c/configure.sh | sh

1.2 Login and install Docker

Install Docker from the Ubuntu apt repository. This will be an older version of Docker but as Kubernetes is tested with old versions of Docker it will work in our favour.

$ sudo apt-get update \
  && sudo apt-get install -qy docker.io

1.3 Disable the swap file

This is now a mandatory step for Kubernetes. The easiest way to do this is to edit /etc/fstab and to comment out the line referring to swap.
To save a reboot then type in sudo swapoff -a.

Disabling swap memory may appear like a strange requirement at first. If you are curious about this step then read more here.

1.4 Install Kubernetes packages

$ sudo apt-get update \
  && sudo apt-get install -y apt-transport-https \
  && curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

$ echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" \
  | sudo tee -a /etc/apt/sources.list.d/kubernetes.list \
  && sudo apt-get update 

$ sudo apt-get update \
  && sudo apt-get install -y \
  kubelet \
  kubeadm \
  kubernetes-cni

1.5 Create the cluster

At this point we create the cluster by initiating the master with kubeadm. Only do this on the master node.

Despite any warnings I have been assured by Weaveworks and Lucas (the maintainer) that kubeadm is suitable for production use.

$ sudo kubeadm init

If you missed a step or there's a problem then kubeadm will let you know at this point.
Take a copy of the Kube config:

mkdir -p $HOME/.kube  
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config  
sudo chown $(id -u):$(id -g) $HOME/.kube/config  

Make sure you note down the join token command i.e.

$ sudo kubeadm join --token c30633.d178035db2b4bb9a 10.0.0.5:6443 --discovery-token-ca-cert-hash sha256:

2.0 Install networking

Many networking providers are available for Kubernetes, but none are included by default, so let's use Weave Net from Weaveworks which is one of the most popular options in the Kubernetes community. It tends to work out of the box without additional configuration.

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

If you have private networking enabled on your host then you may need to alter the private subnet that Weavenet uses for allocating IP addresses to Pods (containers). Here's an example of how to do that:

$ curl -SL "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')&env.IPALLOC_RANGE=172.16.6.64/27" \
| kubectl apply -f -

Weave also have a very cool visualisation tool called Weave Cloud. It's free and will show you the path traffic is taking between your Pods. See here for an example with the OpenFaaS project.

2.2 Join the worker nodes to the cluster

Now you can switch to each of your workers and use the kubeadm join command from 1.5. Once you run that log out of the workers.

3.0 Profit

That's it - we're done. You have a cluster up and running and can deploy your applications. If you need to setup a dashboard UI then consult the Kubernetes documentation.

$ kubectl get nodes
NAME        STATUS    ROLES     AGE       VERSION  
openfaas1   Ready     master    20m       v1.9.2  
openfaas2   Ready         19m       v1.9.2  
openfaas3   Ready         19m       v1.9.2  

If you want to see my running through creating a cluster step-by-step and showing you how kubectl works then checkout my video below and make sure you subscribe
You can also get an "instant" Kubernetes cluster on your Mac for development using Minikube or Docker for Mac Edge edition. Read my review and first impressions here.

tmux – A Powerful Terminal Multiplexer For Heavy Command-Line Linux User

https://www.2daygeek.com/tmux-a-powerful-terminal-multiplexer-emulator-for-linux

tmux stands for terminal multiplexer, it allows users to create/enable multiple terminals (vertical & horizontal) in single window, this can be accessed and controlled easily from single window when you are working with different issues.
It uses a client-server model, which allows you to share sessions between users, also you can attach terminals to a tmux session back. We can easily move or rearrange the virtual console as per the need. Terminal sessions can freely rebound from one virtual console to another.
tmux depends on libevent and ncurses libraries. tmux offers status-line at the bottom of the screen which display information about your current tmux session such as current window number, window name, username, hostname, current time, and current date.
When tmux is started it creates a new session with a single window and displays it on screen. It allows users to create Any number of windows in the same session.
Many of us says it’s similar to screen but i’m not since this offers wide range of configuration options.
Make a note: Ctrl+b is the default prefix in tmux so, to perform any action in tumx, you have to type the prefix first then required options.

Suggested Read : List Of Terminal Emulator For Linux

tmux Features

• Create any number of windows
• Create any number of panes in the single window
• It allows vertical and horizontal splits
• Detach and Re-attach window
• Server-client architecture which allows users to share sessions between users
• tmux offers wide range of configuration hacks

Suggested Read :
(#) tmate – Instantly Share Your Terminal Session To Anyone In Seconds
(#) Teleconsole – A Tool To Share Your Terminal Session Instantly To Anyone In Seconds

How to Install tmux Command

tmux command is pre-installed by default in most of the Linux systems. If no, follow the below procedure to get installed.
For Debian/Ubuntu, use APT-GET Command or APT Command to install tmux.

$ sudo apt install tmux

For RHEL/CentOS, use YUM Command to install tmux.

$ sudo yum install tmux

For Fedora, use DNF Command to install tmux.

$ sudo dnf install tmux

For Arch Linux, use Pacman Command to install tmux.

$ sudo pacman -S tmux

For openSUSE, use Zypper Command to install tmux.

$ sudo zypper in tmux

How to Use tmux

kick start the tmux session by running following command on terminal. When tmux is started it creates a new session with a single window and will automatically login to your default shell with your user account.

$ tmux

You will get similar to above screenshot like us. tmux comes with status bar which display an information’s about current sessions details, date, time, etc.,.
The status bar information’s are below:

• 0 : It is indicating the session number which was created by the tmux server. By default it starts with 0.
• 0:username@host: : 0 is indicating the session number. Username and Hostname which is holding the current window.
• ~ : It is indicating the current directory (We are in the Home directory)
• * : This indicate that the window is active now.
• Hostname : This shows fully qualified hostname of the server
• Date & Time: It shows current date and time

How to Split Window

tmux allows users to split window vertically and horizontally. Let’s see how to do that.
Press (Ctrl+b), % to split the pane vertically.

Press (Ctrl+b), " to split the pane horizontally.

How to Move Between Panes

Lets say, we have created few panes and want to move between them. How to do that? If you don’t know how to do, then there is no purpose to use tmux. Use the following control keys to perform the actions. There are many ways to move between panes.
Press (Ctrl+b), Left arrow – To Move Left
Press (Ctrl+b), Right arrow – To Move Right
Press (Ctrl+b), Up arrow – To Move Up
Press (Ctrl+b), Down arrow – To Move Down
Press (Ctrl+b), { – To Move Left
Press (Ctrl+b), } – To Move Right
Press (Ctrl+b), o – Switch to next pane (left-to-right, top-down)
Press (Ctrl+b), ; – Move to the previously active pane.
For testing purpose, we are going to move between panes. Now, we are in the pane2 which shows lsb_release -a command output.

And we are going to move to pane0 which shows uname -a command output.

How to Open/Create New Window

You can open any number of windows within one terminal. Terminal window can be split vertically & horizontally which is called panes. Each pane will contain its own, independently running terminal instance.
Press (Ctrl+b), c to create a new window.
Press (Ctrl+b), n move to the next window.
Press (Ctrl+b), p to move to the previous window.
Press (Ctrl+b), (0-9) to immediately move to a specific window.
Press (Ctrl+b), l Move to the previously selected window.
I have two windows, first window has three panes which contains operating system distribution information, top command output & kernal information.

And second window has two panes which contains Linux distributions logo information. Use the following commands perform the action.

Press (Ctrl+b), w Choose the current window interactively.

How to Zoom Panes

You are working in some pane which is very small and you want to zoom it out for further work. To do use the following key binds.
Currently we have three panes and i’m working in pane1 which shows system activity using Top command and am going to zoom that.

When you zoom a pane, it will hide all other panes and display only the zoomed pane in the window.

Press (Ctrl+b), z to zoom the pane and press it again, to bring the zoomed pane back.

Display Pane Information

To know about pane number and it’s size, run the following command.
Press (Ctrl+b), q to briefly display pane indexes.

Display Window Information

To know about window number, layout size, number of panes associated with the window and it’s size, etc., run the following command.
Just run tmux list-windows to view window information.

How to Resize Panes

You may want to resize the panes to fit your requirement. You have to press (Ctrl+b), : then type the following details on the yellow color bar in the bottom of the page.

In the previous section we have print pane index which shows panes size as well. To test this we are going to increase 10 cells UPward. See the following output that has increased the pane1 & pane2 size from 55x21 to 55x31.

Syntax: (Ctrl+b), : then type resize-pane [options] [cells size]
(Ctrl+b), : then type resize-pane -D 10 to resize the current pane Down for 10 cells.
(Ctrl+b), : then type resize-pane -U 10 to resize the current pane UPward for 10 cells.
(Ctrl+b), : then type resize-pane -L 10 to resize the current pane Left for 10 cells.
(Ctrl+b), : then type resize-pane -R 10 to resize the current pane Right for 10 cells.

Detaching and Re-attaching tmux Session

One of the most powerful features of tmux is the ability to detach and reattach session whenever you need.
Run a long running process and press Ctrl+b followed by d to detach your tmux session safely by leaving the running process.

Suggested Read : How To Keep A Process/Command Running After Disconnecting SSH Session

Now, run a long running process. For demonstration purpose, we are going to move this server backup to another remote server for disaster recovery (DR) purpose.

$ rsync -avzhe ssh /backup root@192.168.0.161:/backups/week-1/

You will get similar output like below after detached tmux session.

[detached (from session 0)]

Run the following command to list the available tmux sessions.

$ tmux ls
0: 3 windows (created Tue Jan 30 06:17:47 2018) [109x45]

Now, re-attach the tmux session using an appropriate session ID as follow.

$ tmux attach -t 0

How to Close Panes & Window

Just type exit or hit Ctrl-d in the corresponding pane to close it. It’s similar to terminal close. To close window, press (Ctrl+b), &.

Why you should use named pipes on Linux

https://www.networkworld.com/article/3251853/linux/why-use-named-pipes-on-linux.html

Named pipes aren't used all that often, but they provide some interesting options for inter-process communications. Pexels via Pixabay

Related

• 
  How to squeeze the most out of Linux file compression
• 
  Using the Linux find command with caution
• 
  10 Unix commands every Mac and Linux user should know
• 
  Video

  Solo drone has Linux smarts, GoPro mount

Just about every Linux user is familiar with the process of piping data from one process to another using | signs. It provides an easy way to send output from one command to another and end up with only the data you want to see without having to write scripts to do all of the selecting and reformatting.
There is another type of pipe, however, one that warrants the name "pipe" but has a very different personality. It's one that you may have never tried or even thought about — the named pipe.

Also read: 11 pointless but awesome Linux terminal tricks

One of the key differences between regular pipes and named pipes is that named pipes have a presence in the file system. That is, they show up as files. But unlike most files, they never appear to have contents. Even if you write a lot of data to a named pipe, the file appears to be empty.

How to set up a named pipe on Linux

Before we look at one of these empty named pipes, let's step back and see how a named pipe is set up. You would use a command called mkfifo. Why the reference to "FIFO"? Because a named pipe is also known as a FIFO special file. The term "FIFO" refers to its first-in, first-out character. If you fill a dish with ice cream and then start eating it, you'd be doing a LIFO (last-in, first-out) maneuver. If you suck a milkshake through a straw, you'd be doing a FIFO one. So, here's an example of creating a named pipe.

$ mkfifo mypipe
$ ls -l mypipe
prw-r-----. 1 shs staff 0 Jan 31 13:59 mypipe

Notice the special file type designation of "p" and the file length of zero. You can write to a named pipe by redirecting output to it and the length will still be zero.

$ echo "Can you read this?" > mypipe
$ ls -l mypipe
prw-r-----. 1 shs staff 0 Jan 31 13:59 mypipe

So far, so good, but hit return and nothing much happens.

$ echo "Can you read this?" > mypipe

While it might not be obvious, your text has entered into the pipe, but you're still peeking into the input end of it. You or someone else may be sitting at the output end and be ready to read the data that's being poured into the pipe, now waiting for it to be read.

$ cat mypipe
Can you read this?

Once read, the contents of the pipe are gone.
Another way to see how a named pipe works is to perform both operations (pouring the data into the pipe and retrieving it at the other end) yourself by putting the pouring part into the background.

$ echo "Can you read this?" > mypipe &
[1] 79302
$ cat mypipe
Can you read this?
[1]+  Done                    echo "Can you read this?" > mypipe

Once the pipe has been read or "drained," it's empty, though it still will be visible as an empty file ready to be used again. Of course, this brings us to the "why bother?" stage.

Why use named pipes?

Named pipes are used infrequently for a good reason. On Unix systems, there are almost always many ways to do pretty much the same thing. There are many ways to write to a file, read from a file, and empty a file, though named pipes have a certain efficiency going for them.
For one thing, named pipe content resides in memory rather than being written to disk. It is passed only when both ends of the pipe have been opened. And you can write to a pipe multiple times before it is opened at the other end and read. By using named pipes, you can establish a process in which one process writes to a pipe and another reads from a pipe without much concern about trying to time or carefully orchestrate their interaction.
You can set up a process that simply waits for data to appear at the output end of the pipe and then works with it when it does. In the command below, we use the tail command to wait for data to appear.

$ tail -f mypipe

Once the process that will be feeding the pipe has finished, we will see some output.

$ tail -f mypipe
Uranus replicated to WCDC7
Saturn replicated to WCDC8
Pluto replicated to WCDC9
Server replication operation completed

If you look at the process writing to a named pipe, you might be surprised by how little resources it uses. In the ps output below, the only significant resource use is virtual memory (the VSZ column).

ps u -P 80038
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
shs       80038  0.0  0.0 108488   764 pts/4    S    15:25   0:00 -bash

Named pipes are different enough from the more commonly used Unix/Linux pipes to warrant a different name, but "pipe" really invokes a good image of how they move data between processes, so "named pipe" fits pretty well. Maybe you'll come across a task that will benefit significantly from this very clever Unix/Linux feature.

A history of low-level Linux container runtimes

https://opensource.com/article/18/1/history-low-level-container-runtimes

"Container runtime" is an overloaded term.

Image credits : 

Rikki Endsley. CC BY-SA 4.0

Get the newsletter

Join the 85,000 open source advocates who receive our giveaway alerts and article roundups.

At Red Hat we like to say, "Containers are Linux—Linux is Containers." Here is what this means. Traditional containers are processes on a system that usually have the following three characteristics:

1. Resource constraints

Linux Containers

• What are Linux containers?
• What is Docker?
• What is Kubernetes?
• An introduction to container terminology

When you run lots of containers on a system, you do not want to have any container monopolize the operating system, so we use resource constraints to control things like CPU, memory, network bandwidth, etc. The Linux kernel provides the cgroups feature, which can be configured to control the container process resources.

2. Security constraints

Usually, you do not want your containers being able to attack each other or attack the host system. We take advantage of several features of the Linux kernel to set up security separation, such as SELinux, seccomp, capabilities, etc.

3. Virtual separation

Container processes should not have a view of any processes outside the container. They should be on their own network. Container processes need to be able to bind to port 80 in different containers. Each container needs a different view of its image, needs its own root filesystem (rootfs). In Linux we use kernel namespaces to provide virtual separation.
Therefore, a process that runs in a cgroup, has security settings, and runs in namespaces can be called a container. Looking at PID 1, systemd, on a Red Hat Enterprise Linux 7 system, you see that systemd runs in a cgroup.

# tail -1 /proc/1/cgroup

1:name=systemd:/

The ps command shows you that the system process has an SELinux label ...

# ps -eZ | grep systemd

system_u:system_r:init_t:s0             1 ?     00:00:48 systemd

and capabilities.

# grep Cap /proc/1/status

...

CapEff: 0000001fffffffff

CapBnd: 0000001fffffffff

CapBnd:    0000003fffffffff

Finally, if you look at the /proc/1/ns subdir, you will see the namespace that systemd runs in.

ls -l /proc/1/ns

lrwxrwxrwx. 1 root root 0 Jan 11 11:46 mnt -> mnt:[4026531840]

lrwxrwxrwx. 1 root root 0 Jan 11 11:46 net -> net:[4026532009]

lrwxrwxrwx. 1 root root 0 Jan 11 11:46 pid -> pid:[4026531836]

...

If PID 1 (and really every other process on the system) has resource constraints, security settings, and namespaces, I argue that every process on the system is in a container.
Container runtime tools just modify these resource constraints, security settings, and namespaces. Then the Linux kernel executes the processes. After the container is launched, the container runtime can monitor PID 1 inside the container or the container's stdin/stdout—the container runtime manages the lifecycles of these processes.

Container runtimes

You might say to yourself, well systemd sounds pretty similar to a container runtime. Well, after having several email discussions about why container runtimes do not use systemd-nspawn as a tool for launching containers, I decided it would be worth discussing container runtimes and giving some historical context.
Docker is often called a container runtime, but "container runtime" is an overloaded term. When folks talk about a "container runtime," they're really talking about higher-level tools like Docker, CRI-O, and RKT that come with developer functionality. They are API driven. They include concepts like pulling the container image from the container registry, setting up the storage, and finally launching the container. Launching the container often involves running a specialized tool that configures the kernel to run the container, and these are also referred to as "container runtimes." I will refer to them as "low-level container runtimes." Daemons like Docker and CRI-O, as well as command-line tools like Podman and Buildah, should probably be called "container managers" instead.
When Docker was originally written, it launched containers using the lxc toolset, which predates systemd-nspawn. Red Hat's original work with Docker was to try to integrate libvirt (libvirt-lxc) into Docker as an alternative to the lxc tools, which were not supported in RHEL. libvirt-lxc also did not use systemd-nspawn. At that time, the systemd team was saying that systemd-nspawn was only a tool for testing, not for production.
At the same time, the upstream Docker developers, including some members of my Red Hat team, decided they wanted a golang-native way to launch containers, rather than launching a separate application. Work began on libcontainer, as a native golang library for launching containers. Red Hat engineering decided that this was the best path forward and dropped libvirt-lxc.
Later, the Open Container Initiative (OCI) was formed, party because people wanted to be able to launch containers in additional ways. Traditional namespace-separated containers were popular, but people also had the desire for virtual machine-level isolation. Intel and Hyper.sh were working on KVM-separated containers, and Microsoft was working on Windows-based containers. The OCI wanted a standard specification defining what a container is, so the OCI Runtime Specification was born.
The OCI Runtime Specification defines a JSON file format that describes what binary should be run, how it should be contained, and the location of the rootfs of the container. Tools can generate this JSON file. Then other tools can read this JSON file and execute a container on the rootfs. The libcontainer parts of Docker were broken out and donated to the OCI. The upstream Docker engineers and our engineers helped create a new frontend tool to read the OCI Runtime Specification JSON file and interact with libcontainer to run the container. This tool, called runc, was also donated to the OCI. While runc can read the OCI JSON file, users are left to generate it themselves. runc has since become the most popular low-level container runtime. Almost all container-management tools support runc, including CRI-O, Docker, Buildah, Podman, and Cloud Foundry Garden. Since then, other tools have also implemented the OCI Runtime Spec to execute OCI-compliant containers.
Both Clear Containers and Hyper.sh's runV tools were created to use the OCI Runtime Specification to execute KVM-based containers, and they are combining their efforts in a new project called Kata. Last year, Oracle created a demonstration version of an OCI runtime tool called RailCar, written in Rust. It's been two months since the GitHub project has been updated, so it's unclear if it is still in development. A couple of years ago, Vincent Batts worked on adding a tool, nspawn-oci, that interpreted an OCI Runtime Specification file and launched systemd-nspawn, but no one really picked up on it, and it was not a native implementation.
If someone wants to implement a native systemd-nspawn --oci OCI-SPEC.json and get it accepted by the systemd team for support, then CRI-O, Docker, and eventually Podman would be able to use it in addition to runc and Clear Container/runV (Kata). (No one on my team is working on this.)
The bottom line is, back three or four years, the upstream developers wanted to write a low-level golang tool for launching containers, and this tool ended up becoming runc. Those developers at the time had a C-based tool for doing this called lxc and moved away from it. I am pretty sure that at the time they made the decision to build libcontainer, they would not have been interested in systemd-nspawn or any other non-native (golang) way of running "namespace" separated containers.

/dev/[u]random: entropy explained

http://jhurani.com/linux/2017/11/01/entropy-explained.html

Entropy

When the topic of /dev/random and /dev/urandom come up, you always hear this word: “Entropy”. Everyone seems to have their own analogy for it. So why not me? I like to think of Entropy as “Random juice”. It is juice, required for random to be more random.
If you have ever generated an SSL certificate, or a GPG key, you may have seen something like:

We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
++++++++++..+++++.+++++++++++++++.++++++++++...+++++++++++++++...++++++
+++++++++++++++++++++++++++++.+++++..+++++.+++++.+++++++++++++++++++++++++>.
++++++++++>+++++...........................................................+++++
Not enough random bytes available. Please do some other work to give
the OS a chance to collect more entropy! (Need 290 more bytes)

By typing on the keyboard, and moving the mouse, you help generate Entropy, or Random Juice.

You might be asking yourself… Why do I need Entropy? and why it is so important for random to be actually random? Well, lets say our Entropy was limited to keyboard, mouse, and disk IO. But our system is a server, so I know there is no mouse and keyboard input. This means the only factor is your IO. If it is a single disk, that was barely used, you will have low Entropy. This means your systems ability to be random is weak. In other words, I could play the probability game, and significantly decrease the amount of time it would take to crack things like your ssh keys, or decrypt what you thought was an encrypted session.

Okay, but that is pretty unrealistic right? No, actually it isn’t. Take a look at this Debian OpenSSH Vulnerability. This particular issue was caused by someone removing some of the code responsible for adding Entropy. Rumor has it they removed it because it was causing valgrind to throw warnings. However, in doing that, random is now MUCH less random. In fact, so much less that Brute forcing the private ssh keys generated is now a fesible attack vector.

Hopefully by now we understand how important Entropy is to security. Whether you realize you are using it or not.

/dev/random & /dev/urandom

/dev/urandom is a Psuedo Random Number Generator, and it does not block if you run out of Entropy.
/dev/random is a True Random Number Generator, and it does block if you run out of Entropy.
Most often, if we are dealing with something pragmatic, and it doesn’t contain the keys to your nukes, /dev/urandom is the right choice. Otherwise if you go with /dev/random, then when the system runs out of Entropy your application is just going to behave funny. Whether it outright fails, or just hangs until it has enough depends on how you wrote your application.

Checking the Entropy

So, how much Entropy do you have?

[root@testbox test]# cat /proc/sys/kernel/random/poolsize 
4096
[root@testbox test]# cat /proc/sys/kernel/random/entropy_avail 
2975
[root@testbox test]# 

/proc/sys/kernel/random/poolsize, to state the obvious is the size(in bits) of the Entropy Pool. eg: How much random-juice we should save before we stop pumping more. /proc/sys/kernel/random/entropy_avail, is the amount(in bits) of random-juice in the pool currently.

How can we influence this number?

The number is drained as we use it. The most crude example I can come up with is catting /dev/random into /dev/null:

[root@testbox test]# cat /dev/random > /dev/null &
[1] 19058
[root@testbox test]# cat /proc/sys/kernel/random/entropy_avail 
0
[root@testbox test]# cat /proc/sys/kernel/random/entropy_avail 
1
[root@testbox test]# 

The easiest way to influence this is to run Haveged. Haveged is a daemon that uses the processor “flutter” to add Entropy to the systems Entropy Pool. Installation and basic setup is pretty straight forward

[root@b08s02ur ~]# systemctl enable haveged
Created symlink from /etc/systemd/system/multi-user.target.wants/haveged.service to /usr/lib/systemd/system/haveged.service.
[root@b08s02ur ~]# systemctl start haveged
[root@b08s02ur ~]# 

On a machine with relatively moderate traffic:

[root@testbox ~]# pv /dev/random > /dev/null 
  40 B 0:00:15 [   0 B/s] [                    <=>                                                                                                                                                      ]
  52 B 0:00:23 [   0 B/s] [                           <=>                                                                                                                                               ]
  58 B 0:00:25 [5.92 B/s] [                              <=>                                                                                                                                            ]
  64 B 0:00:30 [6.03 B/s] [                                  <=>                                                                                                                                        ]
^C
[root@testbox ~]# systemctl start haveged
[root@testbox ~]# pv /dev/random > /dev/null 
7.12MiB 0:00:05 [1.43MiB/s] [                <=>                                                                                                                                                        ]
15.7MiB 0:00:11 [1.44MiB/s] [                                    <=>                                                                                                                                    ]
27.2MiB 0:00:19 [1.46MiB/s] [                                                               <=>                                                                                                         ]
  43MiB 0:00:30 [1.47MiB/s] [                                                                                                    <=>                                                                    ]
^C
[root@testbox ~]#

Using pv we are able to see how much data we are passing via pipe. As you can see, before haveged, we were getting 2.1 bits per second(B/s). Whereas after starting haveged, and adding processor flutter to our Entropy pool we get ~1.5MiB/sec.

Linux seq Command Tutorial for Beginners (5 Examples)

https://www.howtoforge.com/linux-seq-command

On this page

1. Linux seq command
2. Q1. How seq command works?
3. Q2. How to add a separator?
4. Q3. How to specify output format?
5. Q4. How to use seq with other commands? (Use case 1)
6. Q5. How to use seq with other commands? (Use case 2)
7. Conclusion

Sometimes, you come across a command line tool that offers limited functionality on its own, but when used with other tools, you realize its actual potential. Once such tool is seq, which prints a sequence of numbers. In this tutorial, we will discuss the basics of this command line utility using easy to understand examples.
But before jumping on to that, it's worth mentioning that all examples in this article have been tested on an Ubuntu 16.04 machine.

Linux seq command

As already mentioned, the seq command lets you print a sequence of numbers. Following is its syntax:

seq [OPTION]... LAST
seq [OPTION]... FIRST LAST
seq [OPTION]... FIRST INCREMENT LAST

And here's how the tool's man page explains it:

       Print numbers from FIRST to LAST, in steps of INCREMENT. If FIRST or 
       INCREMENT is omitted, it defaults to 1.  That is, an omitted  INCREMENT 
       defaults to 1 even when LAST is smaller than FIRST.  
       
       The sequence of numbers ends when the sum of the current number and  
       INCREMENT  would  become  greater than LAST.  FIRST, INCREMENT, and LAST 
       are interpreted as floating point values.  INCREMENT is usually positive if
       FIRST  is smaller than LAST, and INCREMENT is usually negative if FIRST
       is greater than LAST.  FORMAT must be suitable for printing  one  argu?
       ment  of type 'double'; it defaults to %.PRECf if FIRST, INCREMENT, and
       LAST are all fixed point decimal numbers with maximum  precision  PREC,
       and to %g otherwise.

Following are some Q&A-styled examples that should give you a better idea on how the seq command works.

Q1. How seq command works?

Basic usage is very easy. All you have to do is to pass a number to seq, and the tool will producein output numbers from 1 to the input number.
For example:

seq 8

Of course, you can also specify the number from which you want the output to begin with.
For example:

seq 3 8

Movin on, you can also set the incremental difference, which is 1 by default. For example, if you want seq to print from 1 to 9, but with a difference of 2, then here's how you can do that:

seq 1 2 9

Q2. How to add a separator?

If you want, you can also have a separator to make the seq output look better. This feature is available through the -s command line option.
For example, the following command intends to use a comma (,) as a separator:

seq -s, 1 9

Q3. How to specify output format?

The seq command allows you to use printf style floating-point FORMAT. This feature is accessible through the -f command line option. The tool's man page doesn't have much information on how to use this option, but the info page contains the required details. Here's what the info page says:

`-f FORMAT'
`--format=FORMAT'
 Print all numbers using FORMAT. FORMAT must contain exactly one
 of the `printf'-style floating point conversion specifications
 `%a', `%e', `%f', `%g', `%A', `%E', `%F', `%G'. The `%' may be
 followed by zero or more flags taken from the set `-+#0 '', then
 an optional width containing one or more digits, then an optional
 precision consisting of a `.' followed by zero or more digits.
 FORMAT may also contain any number of `%%' conversion
 specifications. All conversion specifications have the same
 meaning as with `printf'.

 The default format is derived from FIRST, STEP, and LAST. If
 these all use a fixed point decimal representation, the default
 format is `%.Pf', where P is the minimum precision that can
 represent the output numbers exactly. Otherwise, the default
 format is `%g'.

For example, you can use this option in the following way:

seq -f "%02g" 6

Q4. How to use seq with other commands? (Use case 1)

Suppose you want to perform addition of some numbers, say from 111 to 121. Here's how you can do this using seq:

expr `seq -s " + " 111 121`

Here's the above command in action:

Q5. How to use seq with other commands? (Use case 2)

Suppose you want to create a bunch of new files with names where only an integer value changes. For example, file1, file2, file3, and so on. Here's how you can do this using seq.

touch $(seq -f "file%g" 1 10)

Conclusion

So now you'll agree how useful the seq command is. If you talk about the command line options Seq offers, there's not much of a learning curve, just that you should know when and how to use the command and its options. We've covered several use cases here - should be enough to get you started with the tool. For more information on Seq, head to its man page.

How to Run Your Own Public Time Server on Linux

https://www.linux.com/learn/intro-to-linux/2018/2/how-run-your-own-public-time-server-linux

eddington_a._space_time_and_gravitation._fig._9.jpg

Learn how to run your own public time server and contribute to an essential public good.

Used with permission

Wikimedia Commons: Public Domain

One of the most important public services is timekeeping, but it doesn't get a lot of attention. Most public time servers are run by volunteers to help meet always-increasing demands. Learn how to run your own public time server and contribute to an essential public good. (See Keep Accurate Time on Linux with NTP to learn how to set up a LAN time server.)

Famous Time Server Abusers

Like everything in life, even something as beneficial as time servers are subject to abuse fueled by either incompetence or malice.
Vendors of consumer network appliances are notorious for creating big messes. The first one I recall happened in 2003, when Netgear hard-coded the address of the University of Wisconsin-Madison's NTP server into their routers. All of a sudden the server was getting hammered with requests, and as Netgear sold more routers, the worse it got. Adding to the fun, the routers were programmed to send requests every second, which is way too many. Netgear issued a firmware upgrade, but few users ever upgrade their devices, and a number of them are pummeling the University of Wisconsin-Madison's NTP server to this day. Netgear gave them a pile of money, which hopefully will cover their costs until the last defective router dies. Similar ineptitudes were perpetrated by D-Link, Snapchat, TP-Link, and others.
The NTP protocol has become a choice vector for distributed denial-of-service attacks, using both reflection and amplification. It is called reflection when an attacker uses a forged source address to target a victim; the attacker sends requests to multiple servers, which then reply and bombard the forged address. Amplification is a large reply to a small request. For example, on Linux the ntpq command is a useful tool to query your NTP servers to verify that they are operating correctly. Some replies, such as lists of peers, are large. Combine reflection with amplification, and an attacker can get a return of 10x or more on the bandwidth they spend on the attack.
How do you protect your nice beneficial public NTP server? Start by using NTP 4.2.7p26 or newer, which hopefully is not an issue with your Linux distribution because that version was released in 2010. That release shipped with the most significant abuse vectors disabled as the default. The current release is 4.2.8p10, released in 2017.
Another step you can take, which you should be doing anyway, is use ingress and egress filtering on your network. Block packets from entering your network that claim to be from your network, and block outgoing packets with forged return addresses. Ingress filtering helps you, and egress filtering helps you and everyone else. Read BCP38.info for much more information.

Stratum 0, 1, 2 Time Servers

NTP is more than 30 years old, one of the oldest Internet protocols that is still widely used. Its purpose is keep computers synchronized to Coordinated Universal Time (UTC). The NTP network is both hierarchical, organized into strata, and peer. Stratum 0 contains master timekeeping devices such as atomic clocks. Stratum 1 time servers synchronize with Stratum 0 devices. Stratum 2 time servers synchronize with Stratum 1 time servers, and Stratum 3 with Stratum 2. The NTP protocol supports 16 strata, though in real life there not that many. Servers in each stratum also peer with each other.
In the olden days, we selected individual NTP servers for our client configurations. Those days are long gone, and now the better way is to use the NTP pool addresses, which use round-robin DNS to share the load. Pool addresses are only for clients, such as individual PCs and your local LAN NTP server. When you run your own public server you won't use the pool addresses.

Public NTP Server Configuration

There are two steps to running a public NTP server: set up your server, and then apply to join the NTP server pool. Running a public NTP server is a noble deed, but make sure you know what you're getting into. Joining the NTP pool is a long-term commitment, because even if you run it for a short time and then quit, you'll be receiving requests for years.
You need a static public IP address, a permanent reliable Internet connection with at least 512Kb/s bandwidth, and know how to configure your firewall correctly. NTP uses UDP port 123. The machine itself doesn't have to be any great thing, and a lot of admins piggyback NTP on other public-facing servers such as Web servers.
Configuring a public NTP server is just like configuring a LAN NTP server, with a few more configurations. Start by reading the Rules of Engagement. Follow the rules and mind your manners; almost everyone maintaining a time server is a volunteer just like you. Then select 4-7 Stratum 2 upstream time servers from StratumTwoTimeServers. Select some that are geographically close to your upstream Internet service provider (mine is 300 miles away), read their access policies, and then use ping and mtr to find the servers with the lowest latency and least number of hops.
This example /etc/ntp.conf includes both IPv4 and IPv6 and basic safeguards:

# stratum 2 server list
server servername_1 iburst
server servername_2 iburst
server servername_3 iburst
server servername_4 iburst
server servername_5 iburst

# access restrictions
restrict -4 default kod noquery nomodify notrap nopeer limited
restrict -6 default kod noquery nomodify notrap nopeer limited
            
# Allow ntpq and ntpdc queries only from localhost
restrict 127.0.0.1
restrict ::1

Start your NTP server, let it run for a few minutes, and then test that it is querying the remote servers:

$ ntpq -p
     remote           refid      st t when poll reach   delay   offset  jitter
=================================================================
+tock.no-such-ag 200.98.196.212   2 u   36   64    7   98.654   88.439  65.123
+PBX.cytranet.ne 45.33.84.208     3 u   37   64    7   72.419  113.535 129.313
*eterna.binary.n 199.102.46.70    2 u   39   64    7   92.933   98.475  56.778
+time.mclarkdev. 132.236.56.250   3 u   37   64    5  111.059   88.029  74.919

Good so far. Now test from another PC, using your NTP server name. The following example shows correct output. If something is not correct you'll see an error message.

$ ntpdate -q yourservername
server 66.96.99.10, stratum 2, offset 0.017690, delay 0.12794
server 98.191.213.2, stratum 1, offset 0.014798, delay 0.22887
server 173.49.198.27, stratum 2, offset 0.020665, delay 0.15012
server 129.6.15.28, stratum 1, offset -0.018846, delay 0.20966
26 Jan 11:13:54 ntpdate[17293]: adjust time server 98.191.213.2 offset 0.014798 sec

Once your server is running satisfactorily apply at manage.ntppool.org to join the pool.
See the official handbook, The Network Time Protocol (NTP) Distribution to learn about all the command and configuration options, and advanced features such as management, querying, and authentication. Visit the following sites to learn pretty much everything you need about running a time server.

• NTP: The Network Time Protocol
• Network Time Foundation
• NTP Pool Project
• Network Time Foundation's NTP Support Wiki

Learn more about Linux through the free "Introduction to Linux" course from The Linux Foundation and edX.

Linux ln Command Tutorial for Beginners (5 Examples)

https://www.howtoforge.com/linux-ln-command

On this page

1. Linux ln command
2. Q1. How to create a hard link using ln?
3. Q2. How to create soft/symbolic link using ln?
4. Q3. How to make ln remove existing destination files of same name?
5. Q4. How to make ln create backup of existing files with same name?
6. Q5. How to create links in directory other than the current directory?
7. Conclusion

Sometimes, while working on the command line, you need to create links between files. This can be achieved using a dedicated command, dubbed ln. In this tutorial, we will discuss the basics of this tool using some easy to understand examples. But before we do that, it's worth mentioning that all examples here have been tested on an Ubuntu 16.04 machine.

Linux ln command

As you'd have understood by now, the ln command lets you make links between files. Following is the syntax (or rather different syntax available) for this tool:

ln [OPTION]... [-T] TARGET LINK_NAME   (1st form)
ln [OPTION]... TARGET                  (2nd form)
ln [OPTION]... TARGET... DIRECTORY     (3rd form)
ln [OPTION]... -t DIRECTORY TARGET...  (4th form)

And here's how the tool's man page explains it:

In  the  1st form, create a link to TARGET with the name LINK_NAME. In the 2nd form, create a link 
to TARGET in the current directory. In the 3rd and 4th forms, create links to each TARGET in 
DIRECTORY. Create hard links by default, symbolic links with --symbolic. By default, each 
destination (name of new link) should not already exist. When creating hard links, each TARGET 
must exist. Symbolic links can hold arbitrary text; if later resolved, a relative link is 
interpreted in relation to its parent directory.

The following Q&A-styled examples will give you a better idea on how the ln command works. But before that, it's good you get a understanding of what's the difference between hard links and soft links.

Q1. How to create a hard link using ln?

That's pretty straightforward - all you have to do is to use the ln command in the following way:

ln [file] [hard-link-to-file]

For example:

ln test.txt test_hard_link.txt

So you can see a hard link was created with the name test_hard_link.txt.

Q2. How to create soft/symbolic link using ln?

For this, use the -s command line option.

ln -s [file] [soft-link-to-file]

For example:

ln -s test.txt test_soft_link.txt

The test_soft_link.txt file is a soft/symbolic link, as confirmed by its sky blue text color.

Q3. How to make ln remove existing destination files of same name?

By default, ln won't let you create a link if a file of the same name already exists in the destination directory.

However, if you want, you can make ln override this behavior by using the -f command line option.

Note: You can use the -i command line option if you want to make all this deletion process interactive.

Q4. How to make ln create backup of existing files with same name?

If you don't want ln to delete existing files of same name, you can make it create backup of these files. This can be achieved using the -b command line option. Backup files created this way will contain a tilde (~) towards the end of their name.

Q5. How to create links in directory other than the current directory?

A particular destination directory (other than the current one) can be specified using the -t command line option. For example:

ls test* | xargs ln -s -t /home/himanshu/Desktop/

The aforementioned command will create links to all test* files (present in the current directory) and put them in the Desktop directory.

Conclusion

Agreed, ln isn't something that you'll require on daily basis, especially if you're a newbie. But it's a helpful command to know about, as you never know when it'd save your day. We've discussed some useful command line options the tool offers. Once you're done with these, you can learn more about ln by heading to its man page.

12 Practical Examples Of wget Command In Linux

http://www.linuxandubuntu.com/home/12-practical-examples-of-wget-command-on-linux

Wget is a useful GNU command line utility used to download files from internet. This utility can download the files from servers using popular protocols like HTTP, HTTPS, and FTP. It runs in the background (non-interactive) and hence can be used in scripts and cron jobs. GNU Wget was written by Hrvoje Nikšić and currently, it is under Tim Rühsen, Darshit Shah, and Giuseppe Scrivano.

In this article let us look at 12 useful examples of using wget utility.

​Downloading a file from web

$ wget

This command will download the specified file in the URL to the current directory. The below screenshot captures downloading of Apache HTTP server source code (compressed file) from the URL: http://www-eu.apache.org/dist/httpd/httpd-2.2.32.tar.gz.
​
wget output contains the following details:
​

1. The name of the file being downloaded
2. A progress bar showing percentage downloaded
3. The size of the file that has been downloaded
4. Current download speed
5. The estimated time to complete the download

Downloading a file with specified filename​

To specify a different filename the -O option (uppercase O) is used.

$ wget -O

​Silent download

To make a silent download, “–q” option is used as follows -

$ wget –q

​Resuming partially downloaded file

In order to resume the partially downloaded file, the “–c” option is used as follows -

$ wget –c

​Downloading files in background

With “–b” option, wget start the downloading in background and start writing -​

$ wget –b

​Multiple downloads

For this “-i” option followed by a file containing multiple URLs (one URL per line) can be used. wget will go through each URL and download them all. How simple is that? :-).​

$ wget –i

​Enable debug information

​With “–d” option, more detailed information can be obtained which may be useful when troubleshooting a problem.

​Downloading a file from untrusted URL

It is possible to bypass the verification of the SSL/TLS certificate by using the option: "--no-check-certificate". ​

$ wget --no-check-certificate

​Downloading file from password protected sites

For both FTP and HTTP connections, below command options can be used to pass on the user credentials:

$ wget --user= --password=

However, these parameters can be overridden using the “--ftp-user” and “--ftp-password” options for FTP connections and the “--http-user” and “--HTTP-password” options for HTTP connections.

For FTP connections:

$ wget -–ftp-user= --ftp-password=

For HTTP connections:

$ wget -–http-user= --http-password=

As specifying password on command prompt is not recommended, use of “--ask-password” option is recommended which will prompt for the password, keeping it out of history log.

$ wget -–ftp-user= --ask-password
$ wget –-http_user= --ask-password

​Redirecting wget log to a file

Using “-o” option (lower case “o”), one can redirect the wget command logs to a log file.

$ wget –o

​Downloading a full website

One of the good features of wget command is mirroring. With this feature, entire website can be downloaded. Using “ -m” option it is possible to download an entire website from the web.

$ wget –m

​Specifying download speed limits

Using “—limit-rate” option, the download limit can be restricted. The download limit can be expressed in bytes, kilobytes (with the k suffix), or megabytes (with the m suffix).

$ wget –-limit-rate=

For example, to restrict the speed utp 200  kilo bytes -

$ wget –-limit-rate=200k http://www-eu.apache.org/dist/httpd/httpd-2.2.32.tar.gz

Conclusion

​wget has advanced features available which make it a very powerful command.  It performs well over slow or unstable network connections. In case a download is incomplete due to a network problem, wget will automatically try to continue the download from where it left off.  It can download files larger than 2GB on a 32-bit system. GWget is a GUI utility for wget. So give it a try if you're not a fan of CLI.

Graphics and music tools for game development

https://opensource.com/article/18/1/graphics-music-tools-game-dev

To build a playable game in just three days, you need good, fast, reliable tools.

Image by : 

opensource.com

Get the newsletter

Join the 85,000 open source advocates who receive our giveaway alerts and article roundups.

In early October, our club, Geeks and Gadgets from Marshall University, participated in the inaugural Open Jam, a game jam that celebrated the best of open source tools. Game jams are events where participants work as teams to develop computer games for fun. Jams tend to be very short—only three days long—and very exhausting. Opensource.com announced Open Jam in late August, and more than three dozen games were entered into the competition.

Programming and development

• New Python content
• Our latest JavaScript articles
• Recent Perl posts
• Red Hat Developers Blog

Our club likes to create and use open source software in our projects, so Open Jam was naturally the jam we wanted to participate in. Our submission was an experimental game called Mark My Words. We used a variety of free and open source (FOSS) tools to develop it; in this article we'll discuss some of the tools we used and potential stumbling blocks to be aware of.

Audio tools

MilkyTracker

MilkyTracker is one of the best software packages available for composing old-style video game music. It is an example of a music tracker, a powerful MOD and XM file creator with a characteristic grid-based pattern editor. We used it to compose most of the musical pieces in our game. One of the great things about this program is that it consumed much less disk space and RAM than most of our other tools. Even so, MilkyTracker is still extremely powerful.

mtracker.png

The user interface took a while to get used to, so here are some pointers for any musician who wants to try out MilkyTracker:

• Go to Config > Misc. and set the edit mode control style to "MilkyTracker." This will give you modern keyboard shortcuts for almost everything
• Undo with Ctrl+Z
• Redo with Ctrl+Y
• Toggle pattern-edit mode with the Spacebar
• Delete the previous note with the Backspace key
• Insert a row with the Insert key
• By default, a note will continue playing until it is replaced on that channel. You can end a note explicitly by inserting a KeyOff note with the backquote (`) key
• You will have to create or find samples before you can start composing. We recommend finding Creative Commons licensed samples at websites such as Freesound or ccMixter

In addition, keep the MilkyTracker documentation page handy. It contains links to numerous tutorials and manuals. A good starting point is the MilkyTracker Guide on the project's wiki.

LMMS

Two of our musicians used the versatile and modern music creation tool LMMS. It comes with a library of cool samples and effects, plus a variety of flexible plugins for generating unique sounds. The learning curve for LMMS was surprisingly low, in part due to the nice beat/bassline editor.

lmms_plugins.png

We have one suggestion for musicians trying out LMMS: Use the plugins. For chiptune-style music, we recommend sfxr, BitInvader, and FreeBoy. For other styles, ZynAddSubFX is a good choice. It comes with a wide range of synthesized instruments that can be altered however you see fit.

Graphics tools

Tiled

Tiled is a popular tilemap editor in open source game development. We used it to assemble consistent, retro-looking backgrounds for our in-game scenes.

tiled.png

Tiled can export maps as XML, JSON, or as flattened images. It is stable and cross-platform.
One of Tiled's features, which we did not use during the jam, allows you to define and place arbitrary game objects, such as coins and powerups, onto the map. All you have to do is load the object's graphics as a tileset, then place them using Insert Tile.
Overall, Tiled is a stellar piece of software that we recommend for any project that needs a map editor.

Piskel

Piskel is a pixel art editor whose source code is licensed under the Apache License, Version 2.0. We used Piskel for almost all our graphical assets during the jam, and we will certainly be using it in future projects as well.
Two features of Piskel that helped us immensely during the jam are onion skin and spritesheet exporting.

Onion skin

The onion skin feature will make Piskel show a ghostly overlay of the previous and next frames of your animation as you edit, like this:

onionshow.gif

Onion skin is handy because it serves as a drawing guide and helps you maintain consistent shapes and volumes on your characters throughout the animation process. To enable it, just click the onion-shaped icon underneath the preview window on the top-right of the screen.

onionenable.png

Spritesheet exporting

Piskel's ability to export animations as a spritesheet was also very helpful. A spritesheet is a single raster image that contains all the frames of an animation. For example, here is a spritesheet we exported from Piskel:

sprite-artist.png

The spritesheet consists of two frames. One frame is in the top half of the image and the other frame is in the bottom half of the image. Spritesheets greatly simplify a game's code by enabling an entire animation to be loaded from a single file. Here is an animated version of the above spritesheet:

sprite-artist-anim.gif

Unpiskel.py

There were several times during the jam when we wanted to batch convert Piskel files into PNGs. Since the Piskel file format is based on JSON, we wrote a small GPLv3-licensed Python script called unpiskel.py to do the conversion.
It is invoked like this:

python unpiskel.py input.piskel

The script will extract the PNG data frames and layers from a Piskel file (here input.piskel) and store them in their own files. The files follow the pattern NAME_XX_YY.png where NAME is the truncated name of the Piskel file, XX is the frame number, and YY is the layer number.
Because the script can be invoked from a shell, it can be used on a whole list of files.

for f in *.piskel; do python unpiskel.py "$f"; done

Python, Pygame, and cx_Freeze

Python and Pygame

We used the Python language to make our game. It is a scripting language that is commonly used for text processing and desktop app development. It can also be used for game development, as projects like Angry Drunken Dwarves and Ren'Py have shown. Both of these projects use a Python library called Pygame to display graphics and produce sound, so we decided to use this library in Open Jam, too.
Pygame turned out to be both stable and featureful, and it was great for the arcade-style game we were creating. The library's speed was fast enough at low resolutions, but its CPU-only rendering starts to slow down at higher resolutions. This is because Pygame does not use hardware-accelerated rendering. However, the infrastructure is there for developers to take full advantage of OpenGL.
If you're looking for a good 2D game programming library, Pygame is one to keep your eye on. Its website has a good tutorial to get started. Be sure to check it out!

cx_Freeze

Prepping our game for distribution was interesting. We knew that Windows users were unlikely to have a Python installation, and asking them to install it would have been too much. On top of that, they would have had to also install Pygame, which is not an intuitive task on Windows.
One thing was clear: We had to put our game into a more convenient form. Many of the other Open Jam participants used the proprietary game engine Unity, which enabled their games to be played in the web browser. This made them extremely convenient to play. Convenience was one thing our game didn't have even a sliver of. But, thanks to a vibrant Python ecosystem, we had options. Tools exist to help Python programmers prepare their programs for distribution on Windows. The two that we considered were cx_Freeze and Pygame2exe (which uses py2exe). We decided on cx_Freeze because it was cross-platform.
In cx_Freeze, you can pack a single-script game for distribution just by running a command like this in the shell:

cxfreeze main.py --target-dir dist

This invocation of cxfreeze will take your script (here main.py) and the Python interpreter on your system and bundle them up into the dist directory. Once this is done, all you have to do is manually copy your game's data files into the dist directory. You will find that the dist directory contains an executable file that can be run to start your game.
There is a more involved way to use cx_Freeze that allows you to automate the copying of data files, but we found the straightforward invocation of cxfreeze to be good enough for our needs. Thanks to this tool, we made our game a little more convenient to play.

Celebrating open source

Open Jam is important because it celebrates the open source model of software development. This is an opportunity to analyze the current state of open source tools and what we need to work on in the future. Game jams are perhaps the best time for game devs to try to push their tools to the limit, to learn what must be improved for the good of future game devs.
Open source tools enable people to explore their creativity without compromising their freedom and without investing money upfront. Although we might not become professional game developers, we were still able to get a small taste of it with our short, experimental game called Mark My Words. It is a linguistically themed game that depicts the evolution of a fictional writing system throughout its history. There were many other delightful submissions to Open Jam, and they are all worth checking out. Really, go look!
Before closing, we would like to thank all the club members who participated and made this experience truly worthwhile. We would also like to thank Michael Clayton, Jared Sprague, and Opensource.com for hosting Open Jam. It was a blast.
Now, we have some questions for readers. Are you a FOSS game developer? What are your tools of choice? Be sure to leave a comment below!