<?xml version='1.0' encoding='utf-8' ?>
<!-- Made with love by pretalx v2024.3.1. -->
<schedule>
    <generator name="pretalx" version="2024.3.1" />
    <version>0.4</version>
    <conference>
        <title>Cloud Native Rejekts</title>
        <acronym>cloud-native-rejekts-eu-2019</acronym>
        <start>2019-05-18</start>
        <end>2019-05-19</end>
        <days>2</days>
        <timeslot_duration>00:05</timeslot_duration>
        <base_url>https://cfp.cloud-native.rejekts.io</base_url>
        <logo>https://cfp.cloud-native.rejekts.io/media/cloud-native-rejekts-eu-2019/img/EU_Rejekts_White_X_Transparency.png</logo>
        <time_zone_name>UTC</time_zone_name>
        
        
        <track name="Cloud Native" slug="1-cloud-native"  color="#f90000" />
        
        <track name="Break" slug="2-break"  color="#222222" />
        
    </conference>
    <day index='1' date='2019-05-18' start='2019-05-18T04:00:00+00:00' end='2019-05-19T03:59:00+00:00'>
        <room name='Main Hall' guid='30461ec4-7af9-54d7-af3f-5582ac0b2359'>
            <event guid='2a8586f6-417f-5317-81b9-2b155670b1f3' id='51'>
                <room>Main Hall</room>
                <title>Day 1 - Registration + Reception</title>
                <subtitle></subtitle>
                <type>Opening</type>
                <date>2019-05-18T09:00:00+00:00</date>
                <start>09:00</start>
                <duration>00:45</duration>
                <abstract>Doors and registration desk open to receive attendees.</abstract>
                <slug>cloud-native-rejekts-eu-2019-51-day-1-registration-reception</slug>
                <track>Break</track>
                
                <persons>
                    <person id='53'>TBA</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/DTLE89/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/DTLE89/feedback/</feedback_url>
            </event>
            <event guid='b129b01c-dc1d-5183-879a-bd9e24e8bb9d' id='49'>
                <room>Main Hall</room>
                <title>Cloud Native Rejekts Opening</title>
                <subtitle></subtitle>
                <type>Opening</type>
                <date>2019-05-18T09:45:00+00:00</date>
                <start>09:45</start>
                <duration>00:10</duration>
                <abstract>We look to welcome and provide information to all attendees.</abstract>
                <slug>cloud-native-rejekts-eu-2019-49-cloud-native-rejekts-opening</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='2'>Chris Kuehl</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/CPJPCG/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/CPJPCG/feedback/</feedback_url>
            </event>
            <event guid='ff4c09a5-0db7-53c9-927d-ce1ee092fda5' id='25'>
                <room>Main Hall</room>
                <title>Using BPF to debug your Kubernetes application</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T10:00:00+00:00</date>
                <start>10:00</start>
                <duration>00:30</duration>
                <abstract>I will demo how to use different BPF tools in the Kubernetes developer workflow. Then, I will explain how it works and what support it requires from the Kubernetes installation.</abstract>
                <slug>cloud-native-rejekts-eu-2019-25-using-bpf-to-debug-your-kubernetes-application</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='12'>Alban Crequy</person>
                </persons>
                <language>en</language>
                <description>BPF tools for tracing your Linux system is an area with a lot of developments. This has happened in the bcc project and in bpftrace project. Until recently, bcc and bpftrace were designed to trace one Linux system. This is changing with kubectl-trace, a tool adapting bpftrace for the Kubernetes workflow.

I&#8217;ll present how to use kubectl-trace to trace a Kubernetes pod. I will also present new tools based on bcc to trace syscalls or files opened by a specific pod. Finally, I will explain how it works and what support it requires from the Kubernetes installation.

Slides: https://tinyurl.com/rejekts-bpf-kubernetes</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/VBYM33/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/VBYM33/feedback/</feedback_url>
            </event>
            <event guid='c7b078b3-51c5-5079-93b7-edcf301aa635' id='48'>
                <room>Main Hall</room>
                <title>Building flexible policy with OPA and Kubernetes</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T10:40:00+00:00</date>
                <start>10:40</start>
                <duration>00:30</duration>
                <abstract>Have you ever been asked the question - &#8220;How do we make sure Kubernetes resources conform to our internal policies and procedures?&#8221;. In this session we introduce, how you can audit, validate and mutate Kubernetes resources based custom semantic rules during create, update, and delete operations without recompiling or reconfiguring the Kubernetes API server using Gatekeeper - a policy controller for Kubernetes.</abstract>
                <slug>cloud-native-rejekts-eu-2019-48-building-flexible-policy-with-opa-and-kubernetes</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='21'>Rita Zhang</person><person id='48'>Max Smythe</person>
                </persons>
                <language>en</language>
                <description>Every organization has rules, whether it be that each resource needs to be labelled a specific way or to only use images from specific container repositories. Some of these rules or policies are essential to meet governance or legal requirements and may be based on learning from past experiences. In this session we introduce, how you can audit, validate and mutate Kubernetes resources based custom semantic rules during create, update, and delete operations without recompiling or reconfiguring the Kubernetes API server. These policies are all backed by the Open Policy Agent (OPA), which is a lightweight, general-purpose policy engine for cloud-native environments. We will also demonstrate the work that is being done in the upstream community and provide working samples to start your journey building scalable policy on Kubernetes.

Open Source Repository - https://github.com/open-policy-agent/gatekeeper</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/MKZDRL/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/MKZDRL/feedback/</feedback_url>
            </event>
            <event guid='aceb88af-366f-52b0-b7dd-2c479393ee10' id='39'>
                <room>Main Hall</room>
                <title>Evaluating Firecracker as a container runtime engine</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T11:35:00+00:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>I will explain the overview of the architecture around Firecracker and container runtimes. Then I will show demos for a proof-of-concept implementation.</abstract>
                <slug>cloud-native-rejekts-eu-2019-39-evaluating-firecracker-as-a-container-runtime-engine</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='41'>Dongsu Park</person>
                </persons>
                <language>en</language>
                <description>Firecracker, an open-source project published by Amazon, opens up a lot of interesting perspective to the container ecosystem. It opens up use cases between containers and VMs, making use of KVM without relying on heavyweight Qemu instances. Its integration with the Kubernetes ecosystem has only started its first step with containerd. Obviously it&#8217;s a good starting point. However, it&apos;s also time to think about how we should get the new shape of containers integrated with all other high-level container runtimes.
 
In this talk, I would like to talk about alternative ways of integration for getting Firecracker integrated with multiple container runtimes. A proof-of-concept implementation will be also presented during the talk.
 
From the side of Firecracker, its integration with the Kubernetes ecosystem has only started its first steps, only with containerd &amp; Kata containers. For the diversity of Kubernetes ecosystem, however, we should also think about how we should get Firecracker integrated with all other high-level container runtimes in the cloud-native ecosystem.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/XT9PEB/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/XT9PEB/feedback/</feedback_url>
            </event>
            <event guid='9cf60c74-ef2b-5316-94ce-fb7ac340fb88' id='13'>
                <room>Main Hall</room>
                <title>Prometheus as exposition format for eBPF programs</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T12:15:00+00:00</date>
                <start>12:15</start>
                <duration>00:30</duration>
                <abstract>Because the kernel knows more than your programs.</abstract>
                <slug>cloud-native-rejekts-eu-2019-13-prometheus-as-exposition-format-for-ebpf-programs</slug>
                <track>Cloud Native</track>
                <logo>/media/cloud-native-rejekts-eu-2019/images/GRK7DW/Screenshot_2019-05-18_at_03.03.26.png</logo>
                <persons>
                    <person id='11'>Leonardo Di Donato</person>
                </persons>
                <language>en</language>
                <description>Nowadays every application exposes their metrics via an HTTP endpoint readable by using Prometheus. Recently the exposition format got included into the OpenMetrics standard of the CNCF. Nevertheless, this very common pattern by definition only expose metrics regarding the specific applications being observed.

This talk wants to expose the idea, and a reference implementation, of a slightly different use case that uses **eBPF** programs as a source of information to allow the exposition and collection of kernel and application probes via a **Prometheus** endpoint.

After having showed the architecture of the proposed reference implementation - a Kubernetes operator with a custom resource for BPF programs - we&apos;ll demo the entire solution to grab and present some metrics without having touched any application running on the demo cluster.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/GRK7DW/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/GRK7DW/feedback/</feedback_url>
            </event>
            <event guid='a384bbec-001f-549f-9cd8-68c1cf812af7' id='53'>
                <room>Main Hall</room>
                <title>Lunch</title>
                <subtitle></subtitle>
                <type>Break</type>
                <date>2019-05-18T12:50:00+00:00</date>
                <start>12:50</start>
                <duration>01:30</duration>
                <abstract>Lunch time!</abstract>
                <slug>cloud-native-rejekts-eu-2019-53-lunch</slug>
                <track>Break</track>
                
                <persons>
                    <person id='53'>TBA</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/BTN3CX/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/BTN3CX/feedback/</feedback_url>
            </event>
            <event guid='89f31994-2bdc-58e7-ad62-6924737c7040' id='15'>
                <room>Main Hall</room>
                <title>Highly Effective Kubernetes Deployments with GitOps</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T14:20:00+00:00</date>
                <start>14:20</start>
                <duration>00:30</duration>
                <abstract>I will describe a GitOps based deployment workflow that makes your Kubernetes deployments secure, auditable, and simpler and the process the process and tools you need to put it in place on any cloud.</abstract>
                <slug>cloud-native-rejekts-eu-2019-15-highly-effective-kubernetes-deployments-with-gitops</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='4'>Edaena Salinas</person>
                </persons>
                <language>en</language>
                <description>Over the last year, I&#8217;ve had the privilege of working with a number of development teams as they modernize workloads, make them cloud native, and move them to Kubernetes.  In this talk, I&#8217;ll talk about how many are converging on a GitOps workflow to make their Kubernetes deployments secure, auditable, and simpler and describe the end to end process and tooling you can use to achieve this. This is a practical cloud neutral talk and you&#8217;ll walk away with tools and techniques you can apply to your own Kubernetes deployments.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/LH3PPX/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/LH3PPX/feedback/</feedback_url>
            </event>
            <event guid='b3867ba4-c8b9-53ec-8271-da8f3a21737c' id='34'>
                <room>Main Hall</room>
                <title>Building a CI pipeline for Kubernetes distributions on the cheap</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T15:00:00+00:00</date>
                <start>15:00</start>
                <duration>00:30</duration>
                <abstract>Setting up a CI pipeline for Kubernetes distribution environment can be a daunting - and possibly costly - task, especially when you need to run tests for every change in a distribution focused on high-availability. 

In this talk, I will explain how we built a CI system at Kinvolk based on Concourse CI, where we spin up multiple, parallel multi-node Kubernetes clusters in isolation on a single bare metal machine, in order to automatically run tests for bare-metal Kubernetes deployments. I will discuss the architectural and design choices, the tools that were used, the challenges we faced, and how we addressed them.</abstract>
                <slug>cloud-native-rejekts-eu-2019-34-building-a-ci-pipeline-for-kubernetes-distributions-on-the-cheap</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='22'>Kosy Anyanwu</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/VNXFFH/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/VNXFFH/feedback/</feedback_url>
            </event>
            <event guid='4114e902-b8ad-5851-ba72-680ef8980e4c' id='24'>
                <room>Main Hall</room>
                <title>Observing Enterprise Kubernetes Clusters At Scale</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T15:40:00+00:00</date>
                <start>15:40</start>
                <duration>00:30</duration>
                <abstract>Observing Kubernetes clusters at scale can be challenging. While most companies operate a small number of Kubernetes clusters, Giant Swarm is responsible for hundreds. This scale makes maintaining a responsible level of observability harder.

We aim to present our observability journey, particularly with Prometheus.

This will cover our architectural choices in the past, such as building tooling for managing Prometheus for on-demand Kubernetes clusters, our current usage and drawbacks we&#8217;d like to address, and our plans for the future, such as horizontal scaling and Cortex.

We will also cover our continuous improvement process using post mortems and continuous delivery, which allows us to evolve our metrics, new exporters, and alerting as we discover blind spots.

This talk presents our learnings of handling observability at scale, with in-depth examples from our infrastructure.</abstract>
                <slug>cloud-native-rejekts-eu-2019-24-observing-enterprise-kubernetes-clusters-at-scale</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='27'>Joe Salisbury</person>
                </persons>
                <language>en</language>
                <description>Giant Swarm operates Kubernetes clusters for enterprise, offering a control plane for Kubernetes as a product, and 24/7 support for any managed Kubernetes clusters. As part of this offering, a high degree of observability and monitoring is necessary to respond to and debug operational issues.

In this talk, we will present the learnings from our observability journey to the community, with a focus on how we&#8217;ve progressed with Prometheus. This will detail our path to our current usage of Prometheus, our current architecture and drawbacks, and our plans for the future.

As part of this discussion, we&#8217;ll cover our architectural choices for monitoring our Kubernetes management platform, before moving onto our current setup and areas we&#8217;d like to improve. Towards how we&#8217;d like to improve, we&#8217;ll go into our plans to horizontally scale our Prometheus setup, as well as integrate with Cortex.

We will also dive into our use of post mortems and continuous delivery to provide continuous improvement. This will touch on some related aspects, such as how our alerting has evolved over time, and how we have implemented new Prometheus exporters to improve the observability of Kubernetes, such as through exposing network and DNS metrics.

Our main aim with this talk is to present how we&#8217;re managing observability in a holistic sense. We also believe that the community would be enriched by our learnings, as they can see which decisions we made have had positive outcomes (and which ones haven&#8217;t!).</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/HVZJJ7/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/HVZJJ7/feedback/</feedback_url>
            </event>
            <event guid='86872a02-80c2-5594-af23-283eaf7554de' id='45'>
                <room>Main Hall</room>
                <title>Artifact Registries; Extending OCI Image and Distribution</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T16:35:00+00:00</date>
                <start>16:35</start>
                <duration>00:30</duration>
                <abstract>Container Registries store the images we build, secure, sign, geo-replicate and deploy. They support production workloads we configure authentication for each service and user that must access them.  
Joins as we share the work to extend OCI distribution and image specs to support new artifact types such as Helm and CNAB. We&apos;ll demonstrate how you can author and store new artifacts, leveraging the investments of OCI compliant registries enabling you to focus on the apps and artifacts, without having to manage the infrastructure.</abstract>
                <slug>cloud-native-rejekts-eu-2019-45-artifact-registries-extending-oci-image-and-distribution</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='46'>Steve Lasker</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/VNVWCU/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/VNVWCU/feedback/</feedback_url>
            </event>
            <event guid='42f7da5e-0b3e-5423-af7c-f4b3b888b45c' id='20'>
                <room>Main Hall</room>
                <title>Deep Dive: Deploying Kubernetes on Bare Metal Using the Cluster API</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T17:15:00+00:00</date>
                <start>17:15</start>
                <duration>00:30</duration>
                <abstract>Relative to cloud infrastructure, bare metal environments are more varied and do not expose a unified API. The Cluster API unifies infrastructure management with Kubernetes-native resources, but our previous attempts to use it in bare metal environments show that actuators alone have significant limitations. Kubernetes webhooks offer an alternative that separates the provisioning of Infrastructure from the deployment of Kubernetes, while keeping the declarative model and common tooling provided by the Cluster API.</abstract>
                <slug>cloud-native-rejekts-eu-2019-20-deep-dive-deploying-kubernetes-on-bare-metal-using-the-cluster-api</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='20'>David Watson &amp; Jason DeTiberus</person>
                </persons>
                <language>en</language>
                <description>Today, the Cluster API project has provider implementations for a variety of cloud environments. Users are interested in using the Cluster API to operate clusters in heterogeneous bare metal environments. While machine provisioning varies widely across these environments, software provisioning remains largely the same. Because of this commonality, the cost of maintaining a separate provider for each environment outweighs the benefits.

Attendees will learn how a single Cluster API provider can be used to operate clusters across different bare metal environments. We will show how to implement a webhook to provision machines in a bare metal environment, and how to integrate it with the Cluster API provider. We will also explain in depth the challenges of deploying Kubernetes in a uniform way across different environments using existing tooling (e.g. kubeadm).</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/C7HJP8/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/C7HJP8/feedback/</feedback_url>
            </event>
            <event guid='d79d3830-4603-5436-998a-8634efbd3b3b' id='30'>
                <room>Main Hall</room>
                <title>Lessons learned while scaling Kubernetes to 5k nodes</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-18T17:55:00+00:00</date>
                <start>17:55</start>
                <duration>00:30</duration>
                <abstract>In this talk, we will explore our journey scaling from a couple of hundred nodes to several thousand Kubernetes nodes. Tales will be told on how to scale etcd itself and what a health check every 30 seconds does to the apiserver when running at several thousand nodes.</abstract>
                <slug>cloud-native-rejekts-eu-2019-30-lessons-learned-while-scaling-kubernetes-to-5k-nodes</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='33'>Thomas Graf</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/88DYSP/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/88DYSP/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    <day index='2' date='2019-05-19' start='2019-05-19T04:00:00+00:00' end='2019-05-20T03:59:00+00:00'>
        <room name='Main Hall' guid='30461ec4-7af9-54d7-af3f-5582ac0b2359'>
            <event guid='20433c15-4ebd-5ac6-9a77-0bde2a82e53e' id='52'>
                <room>Main Hall</room>
                <title>Day 2 - Registration and Reception</title>
                <subtitle></subtitle>
                <type>Opening</type>
                <date>2019-05-19T09:00:00+00:00</date>
                <start>09:00</start>
                <duration>01:00</duration>
                <abstract>Doors and registration desk open to receive attendees.</abstract>
                <slug>cloud-native-rejekts-eu-2019-52-day-2-registration-and-reception</slug>
                <track>Break</track>
                
                <persons>
                    <person id='53'>TBA</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/VTTMJ9/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/VTTMJ9/feedback/</feedback_url>
            </event>
            <event guid='aed51c66-fe8f-5d95-a049-0acd07ea3608' id='6'>
                <room>Main Hall</room>
                <title>Getting Developers to Adopt Your Service</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T10:00:00+00:00</date>
                <start>10:00</start>
                <duration>00:30</duration>
                <abstract>Why should I use it?! Introducing new solutions, new technologies or new processes can meet resistance among your developers. Especially when it is a hyped technology such as Kubernetes. 

Listen to what Jessica and her team learned while building Kubernetes as a Service for developers at Meltwater. How human challenges become technical choices, and how communication and education can achieve high adoption rate.</abstract>
                <slug>cloud-native-rejekts-eu-2019-6-getting-developers-to-adopt-your-service</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='8'>Jessica Andersson</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/QGAV7J/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/QGAV7J/feedback/</feedback_url>
            </event>
            <event guid='12fea7bb-f3ad-503f-8090-f92874c8167f' id='38'>
                <room>Main Hall</room>
                <title>The App Developer&apos;s Kubernetes Toolbox</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T10:40:00+00:00</date>
                <start>10:40</start>
                <duration>00:30</duration>
                <abstract>If you&apos;re developing applications on top of Kubernetes, you may be feeling overwhelmed with the vast number of developer tooling in the ecosystem at your disposal. Kubernetes is moving at a rapid pace, and it&apos;s becoming impossible to keep up with the latest and greatest development environments, debuggers, and build, test and deployment tools.

In this talk, we&apos;ll share from our experience building applications on top of Kubernetes at Bitnami. We&apos;ll take a look at the landscape and answer questions like &quot;should my team be using minikube or a shared Kubernetes environment?&quot;, &quot;what&apos;s the difference between Skaffold, Draft and Telepresence?&quot; and &quot;should I be building an operator or a Helm chart?&quot;. We&apos;ll try to discern which tools best fit a scenario or workflow by looking at real-world examples of Kubernetes applications.</abstract>
                <slug>cloud-native-rejekts-eu-2019-38-the-app-developer-s-kubernetes-toolbox</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='40'>Adnan Abdulhussein</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/NUPMTF/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/NUPMTF/feedback/</feedback_url>
            </event>
            <event guid='0fcffaa6-0c74-5be2-8e42-880a60d46456' id='3'>
                <room>Main Hall</room>
                <title>Knowing what your Kubernetes cluster is doing</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T11:35:00+00:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>While running Kubernetes in production, how do you know what the cluster is doing? In this talk Federico will show you how he and his team are using kube-state-metrics in combination with other exporters and logs to get insights into the multi-tenant Kubernetes cluster they run for 40+ development teams at Meltwater. He will focus on metrics for the higher level Kubernetes objects as well as the cloud environment they run the cluster in.</abstract>
                <slug>cloud-native-rejekts-eu-2019-3-knowing-what-your-kubernetes-cluster-is-doing</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='5'>Federico Hernandez</person>
                </persons>
                <language>en</language>
                <description>This talk builds on and extends two other talks from previous KubeCon events:

  - Reveal Your Deepest Kubernetes Metrics (KubeCon 2018 Europe)
  - Monitor The World Meaningful Metrics for Kubernetes Applications and Clusters (KubeCon 2018 NA)

It will start where the other talks end and show real world examples of using metrics from kube-state-metrics for the higher abstraction level Kubernetes objects in combination with other exporters such as aws-limits and log files to get insights into the Kubernetes cluster we are running internally for other development teams at Meltwater. By running Kubernetes in production for over a year we have learnt (sometimes the hard way) to focus on the overall state of the cluster without loosing the possibility to dig into specific details as well as knowing about the state of the cloud environment the cluster runs in. The hard way gave us learnings on which metrics we were lacking and which ones were not needed.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/KMUEGQ/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/KMUEGQ/feedback/</feedback_url>
            </event>
            <event guid='f300d756-34bb-56ee-b7df-aeda6bffd2db' id='36'>
                <room>Main Hall</room>
                <title>Hardware vulnerabilities in cloud-native environments</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T12:15:00+00:00</date>
                <start>12:15</start>
                <duration>00:30</duration>
                <abstract>In late 2017 and throughout 2018 we witnessed the advent of a new class of CPU-level information disclosure vulnerabilities, commonly known as &#8220;Spectre&#8221;, &#8220;Meltdown&#8221;, and (later in 2018) &#8220;Level 1 Terminal Fault&#8221; (l1tf in short, also known as &#8220;Foreshadow&#8221;). 

This talk will give a brief introduction of related CPU design concepts and their concrete exploitation by the above-mentioned vulnerabilities, and discuss available mitigations.

After we&#8217;ve established (or refreshed) our knowledge of the problem field, the main part of the talk will focus on keeping your Kubernetes clusters secured from those vulnerabilities: we will take a full-stack approach and look at common OS  and container abstraction layers in cloud-native scenarios individually - bare metal kernel space, user space, (optional) virtualization, and container runtime  - to discuss weaknesses and mitigations at each of the layers.</abstract>
                <slug>cloud-native-rejekts-eu-2019-36-hardware-vulnerabilities-in-cloud-native-environments</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='38'>Thilo Fromm</person>
                </persons>
                <language>en</language>
                <description>The talk aims to raise awareness as well as spread in-depth understanding of the impact CPU information disclosure flaws have on Kubernetes and its workloads.

Our motivation is to educate our audience to empower folks to be able able to judge by themselves whether their workloads are secure, and to provide options and mitigations should workloads be at risk. Knowledge from this session will help the community to better understand this new vulnerability class, and to maintain security in Kubernetes deployments.

The talk will roughly follow the path of our blog post on the impact of hardware security vulnerabilities in cloud-native environments: https://kinvolk.io/blog/2019/03/hardware-vulnerabilities-in-cloud-native-environments/ .</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/7YSFAF/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/7YSFAF/feedback/</feedback_url>
            </event>
            <event guid='45323dab-c29b-5679-85d0-a30e9f9aa23d' id='54'>
                <room>Main Hall</room>
                <title>Lunch</title>
                <subtitle></subtitle>
                <type>Break</type>
                <date>2019-05-19T12:50:00+00:00</date>
                <start>12:50</start>
                <duration>01:30</duration>
                <abstract>Lunch time!</abstract>
                <slug>cloud-native-rejekts-eu-2019-54-lunch</slug>
                <track>Break</track>
                
                <persons>
                    <person id='53'>TBA</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/PTN7FW/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/PTN7FW/feedback/</feedback_url>
            </event>
            <event guid='b4d05548-d305-5b29-8632-7c7dcb90d396' id='47'>
                <room>Main Hall</room>
                <title>Kubernetes Operators</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T14:20:00+00:00</date>
                <start>14:20</start>
                <duration>00:30</duration>
                <abstract>What even are Kubernetes Operators? Kernel modules for extending Kubernetes.</abstract>
                <slug>cloud-native-rejekts-eu-2019-47-kubernetes-operators</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='47'>Josh Wood</person>
                </persons>
                <language>en</language>
                <description>The Operator pattern for custom Kubernetes controllers extends the platform to automate the management of stateful, complex applications -- think databases, file stores, and other critical components that often have their own notions of clustering. Operators provide a philosophy and a toolkit for extending Kubernetes orchestration to this class of application, as well as, recursively, mechanisms for managing the lifecycle of the Kubernetes platform itself. This talk, a freestyle rap based on a rejected Kubecon proposal, will examine and demo Kubernetes Operators and make you want to use Operators and write one for your own application.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/ZW8MXF/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/ZW8MXF/feedback/</feedback_url>
            </event>
            <event guid='a2954b2a-fb92-545e-a352-5a586b005391' id='42'>
                <room>Main Hall</room>
                <title>Visualizing Canary Rollouts with Istio and Helm</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T15:00:00+00:00</date>
                <start>15:00</start>
                <duration>00:30</duration>
                <abstract>Istio is one of the most important things to happen to continuous delivery/deployment since Kubernetes. In this talk, you&apos;ll learn how to leverage Helm and Istio to create reliable automated deployment. To help us visualize the rollout we&apos;ve built an interactive, open-source app and will ask audiences to help decide if a rollout continues or not.</abstract>
                <slug>cloud-native-rejekts-eu-2019-42-visualizing-canary-rollouts-with-istio-and-helm</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='44'>Dan Garfield</person>
                </persons>
                <language>en</language>
                <description>The secret sauce uses a little-known feature of Helm to create arrays of Kubernetes stacks and Codefresh to manage custom health-checks and keeping the rollouts synchronized.

You don&apos;t want to miss this very visual and interactive talk.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/RNVGKN/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/RNVGKN/feedback/</feedback_url>
            </event>
            <event guid='a77956d7-662a-5128-8fc2-8c6385ce3491' id='32'>
                <room>Main Hall</room>
                <title>Preemptive Autoscaling on any Cloud</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T15:40:00+00:00</date>
                <start>15:40</start>
                <duration>00:30</duration>
                <abstract>Cerebral is an open source, provider agnostic, preemptive Kubernetes cluster autoscaler with pluggable metrics backends and scaling engines. In this talk, we&apos;ll do a deep dive into Cerebral and contrast its methodology with that of the Kubernetes Cluster Autoscaler, which scales only after seeing that pods cannot be scheduled.</abstract>
                <slug>cloud-native-rejekts-eu-2019-32-preemptive-autoscaling-on-any-cloud</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='35'>Matt Kelly</person><person id='52'>Ashley Schuett</person>
                </persons>
                <language>en</language>
                <description>Cluster autoscalers automatically adjust the number of nodes in your cluster without operator intervention. Scaling up is important to meet resource demand while scaling down is useful for cost savings when nodes are underutilized. Within the Kubernetes ecosystem, there are various methods for achieving autoscaling.

We&#8217;ll do a deep dive into Cerebral, an open source, provider agnostic, preemptive autoscaler with pluggable metrics backends and autoscaling engines. We&#8217;ll demo how to use it with a standard backend such as Prometheus, as well as explore use cases for custom backends: scaling based on a growing application queue, for example. This methodology will be contrasted with others such as the Kubernetes Cluster Autoscaler. The audience will also leave with an understanding of different scaling strategies: random, least waste, cost-optimized, and so on.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/9LP3TL/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/9LP3TL/feedback/</feedback_url>
            </event>
            <event guid='d818dcec-f8bb-5bc0-84be-820fed3c68d8' id='21'>
                <room>Main Hall</room>
                <title>Always up-to-date - Dissecting A Kubernetes Upgrade</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T16:35:00+00:00</date>
                <start>16:35</start>
                <duration>00:30</duration>
                <abstract>The Cloud Native community pushes updates very frequently, sometimes for security reasons other times to deliver new features. This means we need to continuously upgrade Kubernetes and the related Cloud Native Stack.

Kubernetes has created a nice way to roll out new application versions, but what about the upgrade of the orchestrator itself, the core addons running on the cluster, or even the infrastructure holding it. 

Thanks to running clusters for multiple customers all over the world Giant Swarm has created a system to roll out any piece of the infrastructure stack without impact to the customer&#8217;s workloads. Our approach is relying on a set of operators to gracefully control the entire process making it reliable and reproducible.

The audience will see the different decisions that have been taken and which problems have been faced over time.</abstract>
                <slug>cloud-native-rejekts-eu-2019-21-always-up-to-date-dissecting-a-kubernetes-upgrade</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='24'>Fernando RIpoll</person>
                </persons>
                <language>en</language>
                <description>Giant Swarm manages cloud infrastructure for enterprises. It means we are in charge of providing Kubernetes clusters to our customers, as well as managing them so they are always running and up to date. 

Since Cloud Native environments are composed of a mixture of different components, people usually struggle to have everything up to date. In order to make it safe and robust, we have created a versioned system where all components of the platform are tracked under a bundle. It brings some benefits like immutability and testability. 
 
A bundle is made of a list of components like the VM, underlying operative system, the Kubernetes release, container runtime, load balancers, VPC peerings, DNS server, etc. Every component defines the version and the changelog since the last occurrence. 

Behind the curtain, a control plane in the form of a Kubernetes cluster holds a system of interconnected operators in charge of ensuring the desired state of the tenant clusters. A custom resource holds the entire configuration of the clusters including the version bundle. Every time there is a component(s) released we create a new bundle. After it is tested, it is promoted to the end user who can trigger the upgrade in her existing clusters. 

As this approach is similar to upstream cluster API efforts, we believe that the community can benefit from our learnings after two years of building and running this architecture. The audience will see which decisions we made, and why using Kubernetes to manage Kubernetes clusters is a great approach in order to keep the clusters up to date in such a dynamic environment.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/GMZRW7/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/GMZRW7/feedback/</feedback_url>
            </event>
            <event guid='877a5fac-bc92-5746-b32d-db9ed9106768' id='12'>
                <room>Main Hall</room>
                <title>OpenMetrics: Prometheus Unbound</title>
                <subtitle></subtitle>
                <type>Lightning talk</type>
                <date>2019-05-19T17:15:00+00:00</date>
                <start>17:15</start>
                <duration>00:05</duration>
                <abstract>The State of the Art of **OpenMetrics** and some fundamentals about it.</abstract>
                <slug>cloud-native-rejekts-eu-2019-12-openmetrics-prometheus-unbound</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='11'>Leonardo Di Donato</person>
                </persons>
                <language>en</language>
                <description>Nowadays every application exposes their **metrics** via an HTTP endpoint readable by using **Prometheus**. Recently the **exposition format** got included into the **OpenMetrics standard** of the **CNCF**. But why a standardization process was needed and is good? And what are the **novelties** and **differences** OpenMetrics introduces?

This lightning talk will answer those questions while presenting the upcoming OpenMetrics official standard.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/ZJKBJX/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/ZJKBJX/feedback/</feedback_url>
            </event>
            <event guid='cfe39134-833f-5bfd-ad84-c3950044457d' id='55'>
                <room>Main Hall</room>
                <title>Which service mesh should I use?</title>
                <subtitle></subtitle>
                <type>Lightning talk</type>
                <date>2019-05-19T17:30:00+00:00</date>
                <start>17:30</start>
                <duration>00:05</duration>
                <abstract>Not sure which service mesh is right for you? In the emerging landscape of service meshes, which should you choose? In this lightning talk, we will demo, Meshery, an open source, multi-mesh playground that deploys different types of service meshes on-demand.</abstract>
                <slug>cloud-native-rejekts-eu-2019-55-which-service-mesh-should-i-use-</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='56'>Lee Calcote</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/M3QJJY/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/M3QJJY/feedback/</feedback_url>
            </event>
            <event guid='0cba15c8-6f45-52c0-8a89-abaeddcf4ca3' id='19'>
                <room>Main Hall</room>
                <title>Zero downtime upgrades of Kubernetes</title>
                <subtitle></subtitle>
                <type>Lightning talk</type>
                <date>2019-05-19T17:40:00+00:00</date>
                <start>17:40</start>
                <duration>00:05</duration>
                <abstract>The Kubernetes project releases a new version every 3 month as well as several bug fix releases in between. You need and want to upgrade your clusters. How do you do that with zero-downtime and no impact on your production workloads? In this lightning talk I will show how my team has come up with a procedure to upgrade a cluster and monitor the upgrade itself. In particular to avoid impact due to nodes becoming &quot;Not Ready&quot;.</abstract>
                <slug>cloud-native-rejekts-eu-2019-19-zero-downtime-upgrades-of-kubernetes</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='19'>Simone Sciarrati</person>
                </persons>
                <language>en</language>
                <description>The team at Meltwater develops and provides  Kubernetes as a Service in a multi-tenant setup internally for 40+ development teams. The base cluster is deployed with Kops and then enhanced with add-ons by the team. During our first &quot;kops rolling-update&quot; runs we have experienced nodes going into &quot;Not ready&quot;. Mainly do to bug #48638/#41916 and the way nodes reach the masters through DNS round-robin. Though our way of doing the upgrade was &quot;triggered&quot; by kops, we think the process and its steps, in particular the way we monitor the upgrade itself and the API functionality during the upgrade, could be interesting and applied to any Kubernetes instance.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/SFTA7W/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/SFTA7W/feedback/</feedback_url>
            </event>
            <event guid='1f84a899-e45d-5aba-9fb0-db45c57d46ec' id='26'>
                <room>Main Hall</room>
                <title>Build Cloud Native Application Bundles with Porter</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T17:55:00+00:00</date>
                <start>17:55</start>
                <duration>00:30</duration>
                <abstract>Learn how to use Porter to create and deploy Cloud Native Application Bundles without knowing the CNAB spec.</abstract>
                <slug>cloud-native-rejekts-eu-2019-26-build-cloud-native-application-bundles-with-porter</slug>
                <track>Cloud Native</track>
                <logo>/media/cloud-native-rejekts-eu-2019/images/ZKNBXH/porter-notext.png</logo>
                <persons>
                    <person id='30'>Carolyn Van Slyck</person><person id='28'>Jeremy Rickard</person>
                </persons>
                <language>en</language>
                <description>When we deploy to the cloud, most of us aren&apos;t dealing with just a single cloud provider or even deployment tool. It seems like even the simplest of applications today need a load balancer, SSL certificates, persistent file storage, DNS, and somewhere in there is your application.

That is a lot to figure out! The Cloud Native Application Bundles specification was created to help address that problem, helping you manage everything in a single package and focus on what you know best: your application. [Porter](https://porter.sh) is a tool that delivers an easy to use, declarative approach to building these bundles. Porter helps you build bundles without needing to be a CNAB expert. Come learn how Porter makes it easier to manage cloud native applications in the messy imperfect hybrid cloud world that we live in.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/ZKNBXH/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/ZKNBXH/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Sidebar' guid='72cb61ea-5031-5a12-9a20-463e9174d69e'>
            <event guid='e007f184-ffbc-52db-8d8f-4dfefb862657' id='23'>
                <room>Sidebar</room>
                <title>Monitoring the NATS messaging system at scale with Elastic Beats</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T11:35:00+00:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>In a world where stateless applications are optimized to run blazing fast, message exchanging cannot be allowed to affect their performance. Having the ability to publish more than 7 million of messages per second, NATS is the sprinter of the messaging queues.

Whereas benchmarks are good indicators for choosing a tool there is no way to confirm its value without monitoring its performance in production. In our team, we use EFK stack to monitor a bunch of microservices running on top of Kubernetes, since EFK tends to be the de facto way to monitor containerized microservices.

Everything started with a task: Ship NATS monitoring data to Elasticsearch. What we achieved: Extending Beats, the Elastic data shipper, with a NATS dedicated module.

Join us in this session to learn more about the journey, how to add value to a CNCF project and give back to the community.

PS. There will be a demo!</abstract>
                <slug>cloud-native-rejekts-eu-2019-23-monitoring-the-nats-messaging-system-at-scale-with-elastic-beats</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='50'>MICHAEL KATSOULIS</person><person id='51'>Stamatis Katsaounis</person>
                </persons>
                <language>en</language>
                <description>In this session we plan to cover the whole process of turning an internal requirement into a very meaningful integration between a CNCF incubating project (NATS) and a CNCF silver member&#8217;s project (Elastic Beats).

First part of the session is going to be about the problem we had to solve. As a team working on Kubernetes microservices, we are using NATS as a messaging queue to ensure the resiliency of the critical paths. Furthermore, we rely on EFK to monitor our stack. Consequently, monitoring of NATS had to be achieved through EFK stack as well.

In the second part of the session we will describe how we came up with the solution, trying to motivate the audience to follow the same successful path when facing similar situations. After investigating our available options, we noticed that Beats project, the Elastic data shipper, could fit in our case if NATS monitoring was supported. And here comes the motivational part. Those days, during an organized hackathon we grabbed the opportunity to work into creating our own NATS Beat which was later added to the official list of community Beats. Today, after Beats maintainers&#8217; request, NATS has its own module in the core of Beats project.

Final part of the session will be dedicated on how to actually use Beats for shipping monitoring data of a running NATS server to an Elasticsearch instance. The audience will have the opportunity to realize the value of NATS module and the benefit of putting effort in community projects.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/LEQHTE/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/LEQHTE/feedback/</feedback_url>
            </event>
            <event guid='2d316767-da18-5483-be88-1c6acc5357ef' id='22'>
                <room>Sidebar</room>
                <title>Test Driven Development Is Dead</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T12:15:00+00:00</date>
                <start>12:15</start>
                <duration>00:30</duration>
                <abstract>Test Driven Development and Code Coverage as a concept and practice is approaching 20 years and we&apos;ve moved on. Sufficiently advanced monitoring is indistinguishable from testing and in this talk I&apos;ll prove it.</abstract>
                <slug>cloud-native-rejekts-eu-2019-22-test-driven-development-is-dead</slug>
                <track>Cloud Native</track>
                <logo>/media/cloud-native-rejekts-eu-2019/images/MWPDUY/tdd-is-dead.png</logo>
                <persons>
                    <person id='25'>Kevin Crawley</person>
                </persons>
                <language>en</language>
                <description>In this session we&apos;ll uncover why both Unit Testing and Integration Testing as a practice doesn&apos;t actually help engineers or operations understand how their applications run in production nor does it help them sleep at night when PagerDuty goes off at 3am. We&apos;ll discuss how modern software delivery organizations are leveraging advances in monitoring and logging systems to analyze the behavior of their production systems in near real time and uncover the mysticism surrounding observability. We&apos;ll smash the ban hammer on those bits of code which should never be tested and show real world examples of tooling such as Opentracing and Prometheus that enable organizations to focus on what matters: is my production application working like it should.

Ultimately, sufficiently advanced monitoring is indistinguishable from testing and in this talk I&apos;ll prove it.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/MWPDUY/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/MWPDUY/feedback/</feedback_url>
            </event>
            <event guid='ab63e6d7-b771-5a65-8771-570c50bed2ab' id='40'>
                <room>Sidebar</room>
                <title>Moving the CNI to User Space</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T14:20:00+00:00</date>
                <start>14:20</start>
                <duration>00:30</duration>
                <abstract>In this presentation we will explain why and how container networking is moving from the kernel into user space through projects such as the Contiv-VPP CNI plug-in (which leverages the Linux Foundation&apos;s fd.io project).</abstract>
                <slug>cloud-native-rejekts-eu-2019-40-moving-the-cni-to-user-space</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='43'>Giles Heron</person>
                </persons>
                <language>en</language>
                <description>Existing container networking solutions rely on Linux Kernel networking (using iptables, eBPF, Open vSwitch etc.) .  This constrains both performance and flexibility. 

User-Space networking offers better performance (especially when combined with technologies such as vector-based forwarding such as d.io VPP) and enables new features to be developed and deployed without requiring changes to the Linux kernel.

Contiv-VPP is a CNI plugin for Kubernetes that leverages fd.io VPP and which provides a full implementation of Kubernetes network policy and of Kubernetes services (usually implemented by kube-proxy, which programs Linux kernel netfilter rules).

We will provide a detailed description, and live demos of Contiv-VPP, and will discuss the challenges we encountered in our implementation.

Finally we will show how user space networking enables Cloud-native Network Functions such as firewalls and VPN gateways.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/W3VULB/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/W3VULB/feedback/</feedback_url>
            </event>
            <event guid='b04c03df-88da-5b12-970b-9fcbdf031d86' id='14'>
                <room>Sidebar</room>
                <title>Consistent user authentication in multi-cloud hosted Kubernetes clusters</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2019-05-19T15:00:00+00:00</date>
                <start>15:00</start>
                <duration>00:30</duration>
                <abstract>As hosted Kubernetes solutions mature, it becomes ever more compelling to operate clusters across multiple cloud providers. A general point of friction can often be the differences in how you are able to authenticate to those clusters. Cloud providers tend to integrate their own proprietary solutions and hosted control planes lack the flexibility to use authentication providers and audit sinks.</abstract>
                <slug>cloud-native-rejekts-eu-2019-14-consistent-user-authentication-in-multi-cloud-hosted-kubernetes-clusters</slug>
                <track>Cloud Native</track>
                
                <persons>
                    <person id='13'>Christian Simon</person>
                </persons>
                <language>en</language>
                <description>During this talk I will show how a reverse proxy in front of the Kubernetes API can implement uniform OIDC authentication across hosted Kubernetes solutions.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/XFNRUH/</url>
                <feedback_url>https://cfp.cloud-native.rejekts.io/cloud-native-rejekts-eu-2019/talk/XFNRUH/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    
</schedule>
