Opensource.

com

Getting started with

Kubernetes

Find out how Kubernetes is an

elegant solution to a wide range
of essential business problems.
Opensource.com . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

About Opensource.com

What is Opensource.com?

Opensource.com publishes stories about creating,

adopting, and sharing open source
solutions. Visit Opensource.com to learn more about how the open source
way is improving technologies, education, business, government, health, law,
entertainment, humanitarian efforts, and more.

Submit a story idea: https://opensource.com/story

Email us: [email protected]

2 Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com

 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . About the Author

Scott McCarty

Scott McCarty At Red Hat, Scott McCarty is technical product

manager for the container subsystem team,
which enables key product capabilities in OpenShift Container Platform and Red
Hat Enterprise Linux. Focus areas includes container runtimes, tools, and images.
Working closely with engineering teams, at both a product and upstream project
level, he combines personal experience with customer and partner feedback to
enhance and tailor strategic container features and capabilities.
Scott is a social media start-up veteran, an e-commerce old timer, and a weathered
government research technologist, with experience across a variety of companies
and organizations, from seven person startups to 12,000 employee technology
companies. This has culminated in a unique perspective on open source software
development, delivery, and maintenance.

Follow Scott McCarty

Twitter: https://twitter.com/fatherlinux

Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com 3

Opensource.com . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Introduction

Kubernetes is a dump truck: Here’s why 5

Chapters

How to navigate the Kubernetes learning curve 6

Kubernetes basics: Learn how to drive first 8
4 tools to help you drive Kubernetes 10
Why containers and Kubernetes have the potential 14
to run almost anything

Get Involved | Additional Resources

Write for Us 15

4 Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Introduction

Kubernetes is a dump
truck: Here’s why
Dump trucks are an elegant solution to a wide range of essential business problems.

Dump trucks are elegant. Seriously, stay with me for

a minute. They solve a wide array of technical
problems in an elegant way. They can move dirt, gravel,
figuration is relative. It really depends on what you are trying
to do. Kubernetes [1] is no different.
Building Kubernetes once isn’t too hard. Equipping Kuberne-
rocks, coal, construction material, or road barricades. They tes? Well, that gets harder. What did you think of KubeCon? How
can even pull trailers with other pieces of heavy equipment many new projects were announced? Which ones are “real”?
on them. You can load a dump truck with five tons of dirt Which ones should you learn? How deeply do you understand
and drive across the country with it. For a nerd like me, Harbor, TikV, NATD, Vitess, Open Policy Agent? Not to mention
that’s elegance. Envoy, eBPF, and a bunch of
But, they’re not easy to use. the underlying technologies in
Dump trucks require a special Linux? It feels a lot like building
driver’s license. They’re also dump trucks in 1904 with the in-
not easy to equip or maintain. dustrial revolution in full swing.
There are a ton of options Figuring out what screws, bolts,
when you buy a dump truck metal, and pistons to use. (Ste-
and a lot of maintenance. ampunk, anyone?)
But, they’re elegant for mov- Building and equipping
ing dirt. Kubernetes, like a dump
You know what’s not el- truck, is a technical problem
egant for moving dirt? A you probably shouldn’t be
late-model, compact sedan. tackling if you are in financial
They’re way easier to buy. services, retail, biological re-
Easier to drive. Easier to maintain. But, they’re terrible at search, food services, and so forth. But, learning how to drive
carrying dirt. It would take 200 trips to carry five tons of dirt, Kubernetes is definitely something you should be learning.
and nobody would want the car after that. Kubernetes, like a dump truck, is elegant for the wide va-
Alright, you’re sold on using a dump truck, but you want riety of technical problems it can solve (and the ecosystem
to build it yourself. I get it. I’m a nerd and I love building it drags along). So, I’ll leave you with a quote that one of my
things. But… computer science professors told us in my first year of col-
If you owned a construction company, you wouldn’t build lege. She said, “one day, you will look at a piece of code and
your own dump trucks. You definitely wouldn’t maintain the say to yourself, ‘now that’s elegant!’”
supply chain to rebuild dump trucks (that’s a big supply Kubernetes is elegant.
chain). But you would learn to drive one.
OK, my analogy is crude but easy to understand. Ease of Links
use is relative. Ease of maintenance is relative. Ease of con- [1] https://kubernetes.io/

Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com 5

How to navigate the Kubernetes learning curve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

How to navigate the

Kubernetes learning curve
Kubernetes is like a dump truck. It’s elegant for solving the problems it’s designed for, but you have to
master the learning curve first.

The journey to Kubernetes [1] often starts

with running one container on
one host. You quickly discover how easy it is to run new ver-
• Two containers
• Two hosts
It’s easy to fire up one web server on port 80 with a
sions of software, how easy it is to share that software with container, but what happens when you need to fire up a
others, and how easy it is for those users to run it the way second container on port 80? What happens when you
you intended. are building a production environment and you need the
But then you need containerized web server to fail over to a second host?

Kubernetes business model

6 Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . How to navigate the Kubernetes learning curve

The short answer, in either case, is you have to move into So yes, there is a learning curve when starting to use a
container orchestration. giant dump truck (or any professional equipment). There’s
Inevitably, when you start to handle the two containers or also a learning curve to use Kubernetes, but it’s worth it be-
two hosts problem, you’ll introduce complexity and, hence, cause you can solve so many problems with one tool. If you
a learning curve. The two services (a more generalized ver- are apprehensive about the learning curve, think through all
sion of a container) / two hosts problem has been around the underlying networking, storage, and security problems in
for a long time and has always introduced complexity. IT infrastructure and envision their solutions today—they’re
Historically, this would have involved load balancers, clus- not easier. Especially when you introduce more and more
tering software, and even clustered file systems. Configu- services, faster and faster. Velocity is the goal nowadays, so
ration logic for every service is embedded in every system give special consideration to the provisioning and de-provi-
(load balancers, cluster software, and file systems). Running sioning problem.
60 or 70 services, clustered, behind load balancers is com- But don’t confuse the learning curve for building or equip-
plex. Adding another new service is also complex. Worse, ping Kubernetes (picking the right mud flaps for your dump
decommissioning a service is a nightmare. Thinking back on truck can be hard, LOL) with the learning curve for using it.
my days of troubleshooting production MySQL and Apache Learning to build your own Kubernetes with so many differ-
servers with logic embedded in three, four, or five different ent choices at so many different layers (container engine,
places, all in different formats, still makes my head hurt. logging, monitoring, service mesh, storage, networking),
Kubernetes elegantly solves all these problems with one and then maintaining updated selections of each component
piece of software: every six months, might not be worth the investment—but
1. Two services (containers): Check learning to use it is absolutely worth it.
2. Two servers (high availability): Check I eat, sleep, and breathe Kubernetes and containers ev-
3. Single source of configuration: Check ery day, and even I struggle to keep track of all the ma-
4. Standard configuration format: Check jor new projects announced literally almost every day. But
5. Networking: Check there isn’t a day that I’m not excited about the operational
6. Storage: Check benefits of having a single tool to model an entire IT mini-
7. Dependencies (what services talk to what databases): verse. Also, remember Kubernetes has matured a ton and
Check will continue to do so. Like Linux and OpenStack before it,
8. Easy provisioning: Check the interfaces and de facto projects at each layer will ma-
9. Easy de-provisioning: Check (perhaps Kubernetes’ ture and become easier to select.
most powerful piece)
Wait, it’s starting to look like Kubernetes is pretty elegant and
pretty powerful. It is. You can model an entire miniature IT Links
universe in Kubernetes. [1] https://kubernetes.io/

Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com 7

Kubernetes basics: Learn how to drive first . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Kubernetes basics:
Learn how to drive first
Quit focusing on new projects and get focused on getting your
Kubernetes dump truck commercial driver's license.

Recently, I saw a thread on Reddit about essential

Kubernetes projects [1]. People seem
hungry to know the bare minimum they should learn to get
It’s more than just Pods; it’s Deployments, Persistent Vol-
ume Claims, Services, routes, etc. With Kubernetes platform
OpenShift [2], you can add builds and BuildConfigs. It will
started with Kubernetes. The “driving a dump truck analogy” take you a day or so to get decent with each of these prim-
helps frame the problem to stay on track. Someone in the itives. Then you can dive in deeper as your use cases be-
thread mentioned that you shouldn’t be running your own come more complex.
registry unless you have to, so people are already nibbling at
this idea of driving Kubernetes instead of building it. Mapping developer-native to traditional IT
The API is Kubernetes’ engine and transmission. Like a environments
dump truck’s steering wheel, clutch, gas, and brake pedal, the Finally, start thinking about how this maps to what you do in
YAML or JSON files you use to build your applications are the a traditional IT environment.
primary interface to the machine. When you’re first learning The user has always been trying to solve a business
Kubernetes, this should be your primary focus. Get to know problem, albeit a technical one. Historically, we have used
your controls. Don’t get sidetracked by all the latest and great- things like playbooks to tie business logic to sets of IT sys-
est projects. Don’t try out an experimental dump truck when tems with a single language. This has always been great
you are just learning to drive. Instead, focus on the basics. for operations staff, but it gets hairier when you try to ex-
tend this to developers.
Defined and actual states We have never been able to truly specify how a set of
First, Kubernetes works on the principles of defined state IT systems should behave and interact together, in a de-
and actual state.
Humans (developers/sysadmins/operators) specify the
defined state using the YAML/JSON files they submit to the
Kubernetes API. Then, Kubernetes uses a controller to an-
alyze the difference between the new state defined in the
YAML/JSON and the actual state in the cluster.
In the example “Defined state and actual state,” the Rep-
lication Controller sees the difference between the three
pods specified by the user, with one Pod running, and
schedules two more. If you were to log into Kubernetes and
manually kill one of the Pods, it would start another one to
replace it—over and over and over. Kubernetes does not
stop until the actual state matches the defined state. This
is super powerful.

Primitives
Next, you need to understand what primitives you can specify
in Kubernetes. Defined state and actual state

8 Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kubernetes basics: Learn how to drive first

veloper-native way, until Kubernetes. If you think about it, and compute resources in a very portable and declara-
we are extending the ability to manage storage, network, tive way with the YAML/JSON files we write in Kuberne-
tes, but they are always
mapped back to “real”
resources somewhere.
We just don’t have to
worry about it in devel-
oper mode.
So, quit focusing on
new projects in the Ku-
bernetes ecosystem and
get focused on driving it.

Links
[1] https://www.reddit.
com/r/kubernetes/
comments/
bsoixc/what_are_
the_essential_
kubernetes_related/
[2] https://www.openshift.
com/

Kubernetes primitives

Mapping developer-native to traditional IT environments

Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com 9

4 tools to help you drive Kubernetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4 tools to help you drive

Kubernetes
Learning to drive Kubernetes is more important that knowing
how to build it, and these tools will get you on the road fast.

I want to emphasize this point: the set of

primitives that you need to learn
are the easiest set of primitives that you can learn to
Katacoda provides ephemeral playgrounds and deeper lab
environments. For example, the Linux Container Internals
Lab [4], which I have run for the last three or four years, is
achieve production-quality application deployments built in Katacoda.
(i.e., high-availability [HA], multiple containers, multiple Katacoda maintains a bunch of Kubernetes and cloud
applications). Stated another way, learning the set of tutorials [5] on its main site and collaborates with Red
primitives built into Kubernetes is easier than learning Hat to support a dedicated learning portal for Open-
clustering software, clustered file systems, load balanc- Shift [6]. Explore them both—they are excellent learning
ers, crazy Apache configs, crazy Nginx configs, routers, resources.
switches, firewalls, and storage backends—all the things When you first learn to drive a dump truck, it’s always best
you would need to model a simple HA application in a tra- to watch how other people drive first.
ditional IT environment (for vir-
tual machines or bare metal).
In this article, I’ll share some
tools that will help you learn to
drive Kubernetes quickly.

1. Katacoda
Katacoda [1] is the easiest way to
test-drive a Kubernetes cluster,
hands-down. With one click and
five seconds of time, you have
a web-based terminal plumbed
straight into a running Kuberne-
tes cluster. It’s magnificent for
playing and learning. I even use
it for demos and testing out new
ideas. Katacoda provides a com-
pletely ephemeral environment
that is recycled when you finish
using it. OpenShift Playground [2]

10 Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 tools to help you drive Kubernetes

2. Podman generate kube

The podman generate kube
command is a brilliant little sub-
command that helps users nat-
urally transition from a simple
container engine running simple
containers to a cluster use case
running many containers (as I
described in the last chapter).
Podman [7] does this by letting
you start a few containers, then
exporting the working Kube
YAML, and firing them up in Ku-
bernetes. Check this out (pssst,
you can run it in this Katacoda
lab [8], which already has Pod-
man and OpenShift).
First, notice the syntax to run
a container is strikingly similar to
Docker: Kubernetes Playground [3]

podman run -dtn two-pizza quay.io/fatherlinux/two-pizza value: xterm

- name: HOSTNAME
But this is something other container engines don’t do: - name: container
value: oci
podman generate kube two-pizza image: quay.io/fatherlinux/two-pizza:latest
name: two-pizza
The output: resources: {}
securityContext:
# Generation of Kubernetes YAML is still under development! allowPrivilegeEscalation: true
# capabilities: {}
# Save the output of this file and use kubectl create -f to import privileged: false
# it into Kubernetes. readOnlyRootFilesystem: false
# tty: true
# Created with podman-1.3.1 workingDir: /
apiVersion: v1 status: {}
kind: Pod ---
metadata: apiVersion: v1
creationTimestamp: "2019-06-07T08:08:12Z" kind: Service
labels: metadata:
app: two-pizza creationTimestamp: "2019-06-07T08:08:12Z"
name: two-pizza labels:
spec: app: two-pizza
containers: name: two-pizza
- command: spec:
- /bin/sh selector:
- -c app: two-pizza
- bash -c 'while true; do /usr/bin/nc -l -p 3306 type: NodePort
< /srv/hello.txt; done' status:
env: loadBalancer: {}
- name: PATH
value: 
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/ You now have some working Kubernetes YAML, which
sbin:/bin you can use as a starting point for mucking around and
- name: TERM learning, tweaking, etc. The -s flag created a service for

Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com 11

4 tools to help you drive Kubernetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

you. Brent Baude [9] is even working on new features when developing primitives to describe your own applica-
like adding Volumes/Persistent Volume Claims [10]. For tions. After you run the above command, your Kubernetes
a deeper dive, check out Brent’s amazing work in his blog namespace (in OpenShift) will be populated by a bunch of
post “Podman can now ease the transition to Kubernetes new, defined resources.
and CRI-O.” [11]
oc get all
3. oc new-app
The oc new-app command is extremely powerful. It’s Open- See the “occ new-app output”:
Shift-specific, so it’s not available in default Kubernetes, but The beauty of this is that you can delete Pods, watch
it’s really useful when you’re starting to learn Kubernetes. the replication controllers recreate them, scale Pods up,
Let’s start with a quick command to create a fairly sophisti- and scale them down. You can play with the template and
cated application: change it for other applications (which is what I did when I
first started).
oc new-project -n example
oc 
new-app -f https://raw.githubusercontent.com/openshift/ 4. Visual Studio Code
origin/master/examples/quickstarts/cakephp-mysql.json I saved one of my favorites for last. I use vi [12] for most of
my work, but I have never found a good syntax highlight-
With oc new-app, you can literally steal templates from the er and code completion plugin for Kubernetes (if you have
OpenShift developers and have a known, good starting point one, let me know). Instead, I have found that Microsoft’s

occ new-app output

NAME READY STATUS RESTARTS AGE
pod/cakephp-mysql-example-1-build 0/1 Completed 0 4m
pod/cakephp-mysql-example-1-gz65l 1/1 Running 0 1m
pod/mysql-1-nkhqn 1/1 Running 0 4m

NAME DESIRED CURRENT READY AGE

replicationcontroller/cakephp-mysql-example-1 1 1 1 1m
replicationcontroller/mysql-1 1 1 1 4m

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE

service/cakephp-mysql-example ClusterIP 172.30.234.135 <none> 8080/TCP 4m
service/mysql ClusterIP 172.30.13.195 <none> 3306/TCP 4m

NAME REVISION DESIRED CURRENT TRIGGERED BY

deploymentconfig.apps.openshift.io/cakephp-mysql-example 1 1 1 config,image(cakephp-mysql-example:latest)
deploymentconfig.apps.openshift.io/mysql 1 1 1 config,image(mysql:5.7)

NAME TYPE FROM LATEST

buildconfig.build.openshift.io/cakephp-mysql-example Source Git 1

NAME TYPE FROM STATUS STARTED DURATION

build.build.openshift.io/cakephp-mysql-example-1 Source Git@47a951e Complete 4 minutes ago 2m27s

NAME DOCKER REPO TAGS

UPDATED
agestream.image.openshift.io/cakephp-mysql-example
im docker-registry.default.svc:5000/example/cakephp-mysql-example latest
About aminute ago

NAME HOST/PORT
PATH SERVICES PORT TERMINATION WILDCARD
ute.route.openshift.io/cakephp-mysql-example
ro cakephp-mysql-example-example.2886795271-80-rhsummit1.environments.katacoda.com
cakephp-mysql-example <all> None

12 Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 tools to help you drive Kubernetes

VS Code [13] has a killer set of plugins that complete the ments, etc. This is a really nice feature when you are build-
creation of Kubernetes resources and provide boilerplate. ing these files from scratch or even modifying the files you
First, install Kubernetes and YAML plugins shown in the create with Podman generate kube.
“VS Code plugins UI” image.
Then, you can create a new YAML file from scratch and Conclusion
get auto-completion of Kubernetes resources. The example These four tools (six if you count the two plugins) will help
“Autocomplete in VS Code” shows a Service. you learn to drive Kubernetes, instead of building or equip-
When you use autocomplete and select the Service re- ping it.
source, it fills in some boilerplate for the object. This is mag-
nificent when you are first learning to drive Kubernetes. You Links
can build Pods, Services, Replication Controllers, Deploy- [1] https://learn.openshift.com/subsystems/container-
internals-lab-2-0-part-1
[2] https://learn.openshift.com/playgrounds/openshift311/
[3]  https://katacoda.com/courses/kubernetes/playground
[4] https://learn.openshift.com/subsystems/container-
internals-lab-2-0-part-1
[5]  https://katacoda.com/learn
[6]  http://learn.openshift.com/
[7]  https://podman.io/
[8] https://learn.openshift.com/subsystems/container-
internals-lab-2-0-part-1
[9]  https://developers.redhat.com/blog/author/bbaude/
[10] https://github.com/containers/libpod/issues/2303
[11] https://developers.redhat.com/blog/2019/01/29/podman-
kubernetes-yaml/
[12] https://en.wikipedia.org/wiki/Vi
[13] https://code.visualstudio.com/
VS Code plugins UI

Autocomplete in VS Code VS Code autocomplete filling in boilerplate for an object

Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com 13

Why containers and Kubernetes have the potential to run almost anything . . . . . . . .

Why containers and

Kubernetes have the potential
to run almost anything
Go beyond deployment of simple applications and tackle day two operations with Kubernetes Operators.

From the beginning, Kubernetes has been able to

run web-based workloads (contain-
erized) really well. Workloads like web servers, Java, and
administrator or, systems administrator) for that workload
type (database, web server, etc) would normally keep in their
notes somewhere in a wiki. The problem with these notes
associated app servers (PHP, Python, etc) just work. The being in a wiki is, for the knowledge to be applied to solve a
supporting services like DNS, load balancing, and SSH (re- problem, we need to:
placed by kubectl exec) are handled by the platform. For the 1. Generate an event, often a monitoring system finds a
majority of my career, these are the workloads I ran in pro- fault and we create a ticket
duction, so I immediately recognized the power of running 2. Human SME has to investigate the problem, even if it’s
production workloads with Kubernetes, aside from DevOps, something we’ve seen a million times before
aside from agile. There is incremental efficiency gain even 3. Human SME has to execute the knowledge (perform
if we barely change our cultural practices. Commissioning the backup/restore, configure the Galera or transaction
and decommissioning become extremely easy, which were replication, etc)
terribly difficult with traditional IT. So, since the early days, With Operators, all of this SME knowledge can be embedded
Kubernetes has given me all of the basic primitives I need to in a separate container image which is deployed before the
model a production workload, in a single configuration lan- actual workload. We deploy the Operator container, and then
guage (Kube YAML/Json). the Operator deploys and manages one or more instances of
But, what happened if you needed to run Multi-master the workload. We then manage the Operators using some-
MySQL with replication? What about redundant data using thing like the Operator Lifecycle Manager (Katacoda tutorial).
Galera? How do you do snapshotting and backups? What So, as we move forward with Kubernetes, we not only
about sophisticated workloads like SAP? Day zero (deploy- simplify the deployment of applications, but also the man-
ment) with simple applications (web servers, etc) has been agement over the lifecycle. Operators also give us the tools
fairly easy with Kubernetes, but day two operations and to manage very complex, stateful applications with deep
workloads were not tackled. That’s not to say that day two configuration requirements (clustering, replication, repair,
operations with sophisticated workloads were harder than backup/restore. And, the best part is, the people who built
traditional IT to solve, but they weren’t made easier with the container are probably the subject matter experts for day
Kubernetes. Every user was left to devise their own genius two operations, so now they can embed that knowledge into
ideas for solving these problems, which is basically the sta- the operations environment.
tus quo today. Over the last 5 years, the number one type
of question I get is around day two operations of complex The conclusion to this e-book
workloads. The future of Kubernetes is bright, and like virtualization
Thankfully, that’s changing as we speak with the advent of before it, workload expansion is inevitable. Learning how to
Kubernetes Operators. With the advent of Operators, we now drive Kubernetes is probably the biggest investment that a
have a framework to codify day two operations knowledge into developer or sysadmin can make in their own career growth.
the platform. We can now apply the same defined state, ac- As the workloads expand, so will the career opportunities.
tual state methodology that I described in Kubernetes basics: So, here’s to driving an amazing dump truck that’s very ele-
Learn how to drive first [1]—we can now define, automate, gant at moving dirt... [2]
and maintain a wide range of systems administration tasks.
I often refer to Operators as “Robot Sysadmins” because Links
they essentially codify a bunch of the day two operations [1] h
 ttps://opensource.com/article/19/6/kubernetes-basics
knowledge that a subject matter expert (SME, like database [2] h ttps://opensource.com/article/19/6/kubernetes-dump-truck

14 Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com

 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Write for Us

Write for Us

In 2010, Red Hat CEO Jim Whitehurst announced the launch of Opensource.com
in a post titled Welcome to the conversation on Opensource.com. He explained,
“This site is one of the ways in which Red Hat gives something back to the open
source community. Our desire is to create a connection point for conversations
about the broader impact that open source can have—and is having—even beyond
the software world.” he wrote, adding, “All ideas are welcome, and all participants
are welcome. This will not be a site for Red Hat, about Red Hat. Instead, this will be
a site for open source, about the future.”

By 2013, Opensource.com was publishing an average of 46 articles per month,

and in March 2016, Opensource.com surpassed 1-million page views for the first
time. In 2019, Opensource.com averages more than 1.5 million page views and
90 articles per month.

More than 60% of our content is contributed by members of open source communities,
and additional articles are written by the editorial team and other Red Hat contributors.
A small, international team of staff editors and Community Moderators work closely
with contributors to curate, polish, publish, and promote open source stories from
around the world.

Would you like to write for us? Send pitches and inquiries to [email protected].

To learn more, read 7 big reasons to contribute to Opensource.com.

Getting started with Kubernetes . CC BY-SA 4.0 . Opensource.com 15