NGINX Core is an eight-hour course that provides the foundation you need to administer, configure, and manage NGINX. Through lecture and hands-on activities you implement NGINX as a web server, load balancer, and reverse proxy. You'll secure your site with SSL/TLS and improve site performance with caching and compression. And you'll learn how to monitor and troubleshoot your site with live activity monitoring, custom logging, and dynamic server configuration. Whether you are new to NGINX, starting your first NGINX project, or refining your DevOps skills, NGINX Core gives you a grounding to build on. NGINX Core is also your gateway to more advanced training topics like Microservices Network Architectures with NGINX, and others.

If you're new to NGINX, NGINX Core is the place to start. If you’re self-taught, or have some working experience with NGINX, NGINX Core will help you solidify your understanding. In NGINX Core, you will implement the most common use cases for NGINX – web server, proxy server, and load balancer  – in a secure, scalable way. As you do, you'll build a solid foundation for moving on to advanced topics, including more complex security considerations and microservices implementation and architecture.

NGINX Core combines lecture, instructor demos, and hands-on activities. Each lecture and instructor demo in NGINX Core is followed by hands-on activities in which you implement the use case in a preconfigured, personal training environment. For example, following the lesson on serving static content, you'll implement a basic web server that serves static content in your environment. In later modules you'll add a simple proxy server, enable security (HTTPS), implement variables and maps, route connections, rewrite and redirect requests, implement a variety of load balancing models, and configure caching.

Objectives

After completing this course you will know how to:

• Serve static content
• Proxy connections to upstream servers
• Configure and customize logging
• Configure HTTPS and site security
• Use variables in rewrites, routing, and maps
• Route connections
• Configure HTTP load balancing with the weighted Round Robin, Least Time, Least Connections, Hash, and IP Hash methods
• Enable live activity monitoring of servers and upstreams
• Implement and manage caching
• Implement compression
• Leverage the NGINX API to dynamically configure servers at runtime
• Install NGINX from binary and source

Audience NGINX Core is intended for admins, architects, and DevOps professionals who are self-taught or new to NGINX.

Prerequisites No prior knowledge of or experience with NGINX is required. Participants should have a basic understanding of web servers and the Unix command line. Required skills include running Unix commands, navigating the file system, and creating and editing text files.

Developing NGINX Modules is a hands-on class that will give you the foundation you need to begin extending NGINX functionality with NGINX modules. The class will begin with a discussion of when and why a new NGINX module might be the best solution for you. We'll then guide you through the development process from the point of view of a first time developer: obstacles encountered and how they were overcome, with particular attention to the sites, blogs, and queries that were most helpful. Next, you'll dive into NGINX internals – the code that is NGINX. You'll get an architectural overview, deep dives into how connections are handled, data types and structures, memory, module structure, and NGINX coding best-practices. You'll then write a simple hello_world module, exploring the build process, dynamic vs static modules, and how to specify its directives. You'll then write and execute tests for your module. Following the hello_world module, you'll write simple access, header filter, and body filter modules. We'll discuss the NGINX Certified Module program, best practices for module development, and the resources we've made available to you. The class wraps up with a panel discussion with our instructors – Valentin Bartenev, Roman Arutyunyan, and Aidan Carson.

Objectives After completing this class you will be able to:

• Describe NGINX internal architecture
• Explain core aspects of NGINX code in the context of module development
• Describe requirements for successful NGINX modules
• Get the resources you need to begin module development
• Create a simple content module
• Create a simple access module
• Create a simple header filter module
• Create a simple body filter module

Audience Developing NGINX Modules is for architects and developers who are interested in extending NGINX core functionality for specific business purposes.

Prerequisites Developing NGINX Modules is intended for developers and advanced administrators with prior development experience. C/C++ and systems programing is recommended. Basic knowledge of configuring, troubleshooting and administering NGINX is highly advised. Although not a requirement, it's ideal for attendees to have taken the NGINX Core course before attending Developing NGINX Modules.

Securing Applications with NGINX is an eight‑hour course for individuals who want a deep understanding of NGINX and NGINX Plus's security features. In this course you'll identify and administer client‑side and upstream encryption (SSL/TLS), configure access control (limit rates, blacklisting/whitelisting), set up authentication (HTTP Basic Auth, OAuth 2.0), and tune the NGINX proxy to have reliable, persistent, fast, and secure connections. The second half of the course explores using NGINX Plus to secure API traffic, authenticate users with OpenID Connect, and block malicious traffic with the NGINX WAF dynamic module based on ModSecurity 3.0.

Objectives

After completing this course you will know how to:

• Use core NGINX security directives
• Correctly authenticate and sign APIs using NGINX Plus
• Combine technologies to achieve single sign‑on (SSO)
• Install and configure the NGINX WAF
• Administer OWASP, with an awareness of its benefits and limitations

Audience Securing Applications with NGINX is intended for NGINX developers, DevOps, and administrators who want to make sure their solutions are a secure as they can be.

Prerequisites Completion of the NGINX Core course, or comparable experience.

Every company must learn plan and execute like a technology company. Products, services, and distribution mechanisms are all going digital at breakneck speeds. To win customers and provide a compelling digital experience, organizations must deploy technology that enables them to optimize digital delivery, as well as react quickly to ever-changing business and consumer needs. In this opening keynote, NGINX CEO Gus Robertson will talk about the major trends impacting enterprises in the digital era, how companies can master the transition, and how the NGINX Application Platform helps.

Learn about the exciting technology coming from NGINX and how our solutions give organizations the freedom of choice and enable the agility they need to modernize faster.

Isa describes how her team went from testing monolithic applications (with its challenges) to testing integrations of hundreds of microservices. They found that a microservices architecture comes at a price: brittle, slow, and infra-dependent tests. In this session, she answers questions like: how can you have robust, fast, reliable and well-scoped tests? How can you be the first one to know about problems in production? And how can you guarantee a rollout plan that affects the fewest customers possible if something goes wrong? This session is about Isa's journey at Atlassian and CloudBees to develop a testing strategy that protected customers in the face of dozens of releases per day of different services at the same time.

In this talk we would discuss common patterns on Hybrid and Multi-Clouds application deployments and some tools and technologies that are enabling application deployment and management at scale.

At The Atlantic we create a new beta environment for every pull request. This allows developers and the people doing QA to review site changes quickly while keeping costs low. To facilitate this we use a combination of Github, Jenkins, NGINX (with uWSGI cheaper subsystem for Python applications/Passenger for Node) and a few Python scripts. The result is a server configuration that can handle a large number of environments because it only uses resources as necessary. This talk will be valuable to anyone interested in release automation or maximizing server resource usage with NGINX (+uWSGI/Passenger).

In this session Ernesto describes how AppNexus replaced all of the F5 hardware load balancers in its global data centers with NGINX Plus, detailing the motivations for the migration, the pitfalls, and the successes. Major concerns with the F5 load balancers were SSL capacity limitations and the lack of scalability and flexibility. The workaround offered by F5 was cost-prohibitive, unrealistic, and didn't address all the issues. Ernesto also covers in detail the steps and challenges his team went through, from the proof of concept through to the implementation and operation phases. After presenting HTTP and HTTPS benchmark performance data, he discusses some improvements and fixes to NGINX that he thinks would make it a more complete and robust alternative to other hardware-based load balancing solutions.

Got some online nginx processes eating too much memory, CPU time, or disk I/O resources? Got some very slow requests that occur randomly online, but cannot be reproduced offline? Seen some mysterious NGINX error log messages but have no clues about the actual causes? Bothered by some random nginx process crashes and core dumps in production? In this session, Yichun investigates various real‑world performance and other behavioral issues in the context of NGINX and OpenResty, and explains how to use dynamic tracing and other advanced postmortem debugging technologies to quickly pinpoint the causes online without disrupting production services.

Yichun describes and compares the advantages and disadvantages of various open source debugging frameworks like GDB, SystemTap, and BCC/eBPF, with a brief discussion of the unique challenges of tracing Docker containers in production. He then introduces the new OpenResty Trace platform which unifies these debugging technologies and improves their usability, scalability, and extensibility to a new level, especially in the context of distributed online systems like a microservices mesh or traffic gateway clusters as in a CDN network. He includes examples of writing custom tracing tools using the universal debugging languages provided by OpenResty Trace.

Yichun also uses real examples to demonstrate the use of advanced tracing tools atop OpenResty Trace for the NGINX core and the OpenResty core with LuaJIT. He covers tracing other traditional backend services running behind NGINX or OpenResty via FastCGI, uWSGI, or NGINX Unit, like PHP, Python, Perl, and Ruby. He concludes with examples of tracing data services like PostgreSQL, Memcached, and Redis accessed by NGINX, OpenResty, or their backend applications.

This is a true microservices journey. Almost a year ago we started with nothing more than a vision. Build a web application hosted on AWS and driven by APIs. Make it secure, lightweight, and fast. It needed to be stable and flexible. And have fun while doing it!

We will start our Journey at the very beginning. From a concept over the first AWS Infrastructure setup in dev to the production ecosystem with NGINX Plus as in important component at the end.

Specifically, this talk will discuss the concept behind the API gateway and the traffic routing to Microservices running with Kubernetes in AWS.

Back in 2015, a small, scrappy group of engineers set out to replace a commercial API management gateway with an in-house solution based on NGINX. A year later they emerged, singed but triumphant, with hundreds of existing services transparently migrated to the new platform. Latencies were reduced and acclaim rang out: “The old 50th percentile is the new 99th!” clients said with glee.

The improvements drove unforeseen growth. Over two years, the number of services hosted more than doubled. Data centers came and went. Thousands of new credentials were added to the system. Transaction rates that once peaked at 2,000 RPS grew to 33,000. The small DevOps team, in its rush to stop paying for a commercial solution, had made a strategic decision to hold off on delivering self-service. Now they had no choice but to prioritize the manual labor required to add services and credentials while working towards self service, before eventually delivering self-service to its consumers.

In this case study, Christopher unpacks events as they unfolded, looks at the decisions that were made, and describes the lessons learned from the challenges his team faced.

When the demand for a video streaming platform grows from tens to hundreds of Gigabit, some scaling issues are likely to crop up. In this talk I will zoom in on 3 topics:

1. Load balancing. How you can write your own load balancer in your language of choice to steer the video traffic with as little overhead as possible.
2. Content protection. How the NGINX OpenResty LUA module can be used to protect against copying of deep links by third parties.
3. Optimizations. When your site is https, it's likely that the streaming content should be https too, in order to avoid mixed content warnings from the browser. What does it take to serve 20Gbit of https traffic per streaming server.

At the NPO we host the video streaming platform for the largest Dutch news & sports network. At peak times -- e.g. during important soccer matches or main news events -- the NPO platform serves approximately 450,000 concurrent viewers which translates to 450Gbit of network traffic.

At the heart of modern application architectures is the HTTP API. They enable applications to be built rapidly, maintained easily, and scaled at will. API gateways are typically deployed as an additional layer in the application delivery environment, bringing additional complexity and points of failure. In this session, Liam will demonstrate how to use the API gateway you already have - NGINX!

This session will provide actionable tips, configuration snippets and live demos of NGINX deployed as an API gateway. We will look at best practice configuration for delivering REST/JSON and gRPC APIs with NGINX.

In this session, Charles discusses different architectures for adopting microservices, including the NGINX Microservices Network Architectures. These architectures will be placed in the context of both migration of existing monolithic applications and "green field" applications. After the session, attendess will understand best practices for determining how microservices should be coupled, as well as how to use NGINX to ensure that the microservices are loosely coupled. In addition, we'll look at some of the advanced features of NGINX Plus within a microservices architecture, with a focus on service discovery, load balancing, health monitoring, and security.

In this session Owen and Vladimir share strategies for running multiple NGINX and NGINX Plus instances in a cluster. They look in depth at methods for sharing traffic across instances, and at the zone‑synchronization module provided in NGINX Plus for sharing run‑time state.

When you use NGINX as a load balancer and/or application server, what challenges and problems will you face? As a managed hosting provider from Berlin, we (SysEleven) use NGINX in almost every setup within our virtual environment. We will show you how we deal with NGINX within our own stack and how we manage to easily configure a NGINX server with puppet.

To date, CDNs have largely been deployed as overlay systems exploiting DNS or redirects to guide clients to the best cache. While this has served the industry well, delivery systems will need to adapt and integrate into the network rather than simply riding on top of it if forecasts are accurate. This talk discusses a concept which attempts to converge resources and routing to provide more efficient delivery, more control of resource reachability and easier sharing of delivery infrastructure.

What's new in NGINX recently? While this question is easily answered with a simple "try reading CHANGES", in some cases just reading might not be enough – and nobody tries to read it anyway. Even those who have actually read it might benefit from some background on why the changes were introduced and from more details on how to use them properly.

In this session Maxim summarizes various new features and changes in the NGINX 1.13.x branch (now available in the stable 1.14.x branch). In particular, he discusses:

• Basic TLS 1.3 support
• The gRPC proxy module (ngx_http_grpc_module)
• The mirror module (ngx_http_mirror_module)
• HTTP/2 server push
• Monotonic clock support

He also covers what is being developed in the current mainline branch (1.15.x), including:

• Deprecation of the ssl directive
• The Random load‑balancing algorithm
• Upstream keepalive timeout and requests limiting
• TLSv1.3 early data support

The session concludes as everyone reads through CHANGES together (and with expression!) and takes a look at some examples on how to use new features properly.

To get the most from this session, review CHANGES beforehand at nginx.org/en/CHANGES

Help us shape the Controller roadmap! We will start with an interactive demonstration of NGINX Controller where audience questions are expected and welcomed as we demonstrate Controller functionality, peppered with stories of the responses from our customers and prospects so far. We will end with a Q&A session on our upcoming Controller roadmap, let us know what you would like to see and what you think of the product so far!

The Ingress controller is one of the most critical parts of Kubernetes platform, acting as the entry point for all incoming traffic to applications running on Kubernetes. That’s why it must be built on top of a proven and reliable load‑balancing technology, such as NGINX. The NGINX Ingress controller combines the benefits of using the Kubernetes control plane to manage load‑balancing configuration with the performance, reliability, and advanced features of NGINX or NGINX Plus. Additionally, the NGINX Ingress controller integrates NGINX with cloud‑native tools such as Helm and Prometheus, which are rapidly gaining adoption in production Kubernetes environments.

This session is for beginning or intermediate Kubernetes users who are looking to deliver applications on Kubernetes in production. Michael shows how to successfully load balance HTTP as well as TCP/UDP applications on Kubernetes with NGINX Ingress controller. Topics include:

• Installation through Kubernetes manifests or Helm
• Configuration of load balancing for HTTP and TCP/UDP applications
• Monitoring using Prometheus
• Troubleshooting in case of problems
• Extensions that support advanced requirements

DDoS threats have been evolving rapidly in recent years, to the point where they have become a community-wide problem. The past two years have seen the spawning of numerous IoT-related working groups, mostly in response to the infamous 1.1-Tbps, IoT-based DDoS attack in autumn 2016. Fast-forward a year and half, and we see even more disastrous attacks.

In this session Artyom aims to dissect the DDoS threat. He describes the ISO/OSI layers, offering a mutually exclusive and collectively exhaustive classification of DoS attacks, a description of what makes them possible, and a set of possible ways to mitigate attacks of any kind.

The session is based on apersonal experience. It is vendor-agnostic and doesn't cover or promote any solutions available on the market. Attendees are welcome to use the information to guide them in building their own solution.

Come and learn about how the newest Multilingual and Dynamic App Server NGINX Unit can fit into your environment.

Are you using the Kubernetes Ingress Controller and want to monitor the traffic flowing through it? How do you measure the health and performance of all your microservices in a Kubernetes environment? Look no further than NGINX Plus and Prometheus (with a little bit of Grafana for some good looking dashboards). In this session we will cover the NGINX Plus API and Status, the NGINX Prometheus Exporter, and accessing the rich data in Prometheus and through Grafana.

DDoS threat has been rapidly evolving recently, up to the point when it started to be a community-wide problem. Numerous IoT-related working groups were spawned throughout the last 2 years mostly due to the infamous 1,1 Tbps IoT DDoS attack in autumn 2016. Fast-forward 1,5 years, and we see attacks even more disastrous.

This workshop aims at dissecting the DDoS threat. It goes over the ISO/OSI layers, offering a mutually exclusive and collectively exhaustive classification of denial-of-service attacks, a description of what makes them possible, and a set of possible ways to mitigate attacks of any kind.

The tutorial is based on a personal experience. It is vendor-agnostic and doesn't cover or promote any solutions available on the market, an attendee is welcome to use this as a guide to build their own.

Hear a recap of all the product announcements we're making a NGINX Conf 2018, as well as a preview of our roadmap and key ecosystem integrations. Owen will also cover key enhancements to our open source projects, as well as tee-up the deep-dives and demos you'll see across all aspects of the NGINX Application Platform.

In this keynote session we will share the NGINX roadmap and how it is influenced by the technology trends affecting our customers and the open source community. We will take a look at the latest enhancements to NGINX and NGINX Plus, including a demonstration of new capabilities just released with NGINX Plus R16.

Hear about NGINX Controller: The history behind its creation, the vision of where we are taking the product and how it fits into the overall product and corporate strategies, a brief demonstration of our current release, and a high-level roadmap of upcoming functionality.

The NGINX Application Platform is made up of a portfolio of NGINX products and extended by our rich ecosystem of technology partners. In this keynote, we'll cover some of the more interesting ecosystem solutions including Kubernetes, ModSecurity, Red Hat OpenShift, and others. We'll also discuss how we're evolving our API gateway capabilities.

NGINX Unit is the new dynamic web and application server, announced last year. It's open source and is now available for production use. Unit supports PHP, Python, Go, Ruby, and Perl.

In this keynote session we will discuss the latest news and update everyone on the progress. We will also discuss the role of where code can be executed in your infrastructure -- as part of your app server or in the delivery infrastructure using something like NGINX JavaScript.

Every organization is undergoing a transformation. In this journey, the technology choices we make, our architectural decisions, and the pace at which we deliver IT services determine whether we make the business impact required to succeed. No one escapes digital disruption, but we can get ahead of it or even create our own waves of disruption in our market. Margaret Dawson, who works with enterprises and governments worldwide, will cut through the hype of digital transformation and focus on how organizations are thinking and moving into next-generation architectures, agile processes, and collaborative cultures. Through real-world examples, she will discuss the market dynamics and what it takes to be a digital leader. Whether you’re a digital laggard or in the middle of a major transformation, this session will give you ideas and new perspectives.

In the internet-of-things (IoT) nobody knows you are a fridge. Add a couple of trillion more connected devices and DevOps teams are facing a new challenge. As IoT connectivity utilizing LTE CAT1/CAT M1 and narrowband continues to become more prevalent globally, it presents new challenges in building for speed, scale, and flexibility in the DevOps space.

Building infrastructure to deal with millions of low bandwidth devices has become even more critical, requiring that you ultimately move the power of NGINX ever closer to the edge -- and soon beyond.

In this session we'll look closely at how tiny IoT compute devices work, delve into the connectivity challenges of the IoT world, and explore some of the ways to deal with building out scale with help from NGINX. We'll bring all together with a demo of IoT devices and NGINX in action.

Capital One uses NGINX for our highest throughput, lowest latency applications. Follow our journey as we started with our API Gateway as our first NGINX application, and then based on that success, rolled our several other applications. NGINX's single threaded event loop with OpenResty module for writing custom Lua code has enabled us to scale our applications to 12 Billion operations per day, a peak of 2 million operations per second and being able to hold our latency to 10-30 milliseconds.

In the past few years, the microservices architecture became more mainstream, as large enterprises have started adopting it for its promise to enable them to deliver software faster, innovate and embrace newer technologies more easily, and have the freedom to react and make informed decisions. However, most adopters have ended up with a “distributed monolith”, unable to realize the true benefits of architectures like polyglot microservices.

In this session, Mohamad shares his experience working with microservices at Verizon. He reviews his team's journey to their Microservices 2.0 solution, including the challenges they faced along the way as different teams adopted different technology stacks to build microservices. With Microservices 2.0, the strategy is to leverage the “platform” (Kubernetes + service mesh) as the "outer architecture" in order to build business‑focused polyglot services that are decoupled from it.

Sometimes you have business goals which can be reached by developing your own modules for NGINX. NGINX modules can be business oriented and contain some business logic as well. However, how do you decide for certain that a module should be developed? How might NGINX help you with development?

In this session, Vasiliy provides the detailed knowledge you need to build your own NGINX modules, including details about NGINX's core, its module architecture, and guiding principles for NGINX code development. Using real‑world case studies and business scenarios, he answers the question, "Why and when do you need to develop your own modules?"

This session will be quite technical. To get the most out of it, attendees need at least intermediate‑level experience with NGINX code.

Speed is key for most users. Slow performance in optimization models can in some cases be solved with parameter tuning. In this session, Amir explains how to maximize NGINX performance and covers important aspects of performance tuning in an infrastructure.

What is the total cost of ownership (TCO) of the NGINX Application Platform? In this session, Karthik explains how the NGINX Application Platform has enabled a large B2C enterprise to reduce costs and realize operational efficiencies by simplifying its app‑delivery tool set from 13 distinct solutions down to just 3. Based on feedback from both traditional infrastructure and operations (I&O) and DevOps teams, he describes how NGINX customers have leveraged the NGINX Application Platform's features to maximize ROI.

In this session Dmitry covers njs (the NGINX JavaScript module, formerly called nginScript) in depth. He explains why we created a different implementation of JavaScript and why NGINX needs a different kind of VM. He goes into detail on the execution model and interpreter. Dmitry describes how users of NGINX and NGINX Plus are using njs to solve real solve real‑world problems, but also use cases where njs might not be the best solution. He concludes with a sneak preview of future plans for njs.

NGINX Plus and the NGINX RTMP module offer many streaming features. In this session, Seungyeob talks about challenges his team encountered while developing streaming services based on NGINX, and shares their experiences solving problems. He explains how to encrypt HLS, handle non-standard MP4 files published by customers, and deliver high-bitrate content (UHD videos), and do live low-latency streaming, topics which are now attracting attention from the streaming industry.

Michael explains how developers can use NGINX and Docker to show business users their progress easily without running into the resource constraints imposed by limited testing environments. His team overlays its development version of an application on top of the current production systems, enabling them to see just the new changes and how they interact with the rest of the site. The team uses NGINX to manage the routing for the over 20 separate small applications that make up the user experience, even as each application iterates quickly on multiple features. In combination with Docker, this gives them the benefits of instant environments despite having old, difficult-to-manage monolithic applications in the stack.

In this session Oleg describes the internal architecture of the EDGE network at Dropbox, including the data centers, PoP locations, and traffic transit patterns. He covers the traffic management approaches in detail for several flows: ingress, internal, and egress.

In this session Grant makes a technical deep dive into NGINX configuration files: examining their structure, talking about how to use an NGINX open source project to create a JSON representation of them, and how NGINX Controller uses this structure to analyze your configuration to check for common errors and "gotchas".

We all know that performance is a critical factor in the success of applications and websites, but it's not always clear how to improve it. Code quality and infrastructure are of course important, but in many cases, you can vastly improve the end-user experience of your application by focusing on some very basic application-delivery techniques. One such technique is implementing and optimizing caching in your application stack.

In this session, Kevin offers an introduction to the basic principles of content caching and outlines how NGINX caches responses, describing NGINX’s unique management process and how the cache metadata is stored on disk. Along the way, Kevin shares techniques for using NGINX's web cache features that can help both novice and advanced users improve performance. He reviews and analyzes all of the available caching directives and parameters, showcases a working example that enables basic caching functionality, and explores various advanced caching implementations from the perspectives of both NGINX configuration and architectural implementation .

NGINX Unit is different from NGINX in terms of its architecture, use cases, and its place in the application stack, but it's very similar in its development culture. As in his session about the NGINX changelog, in this session Nick describes the new features and other changes introduced in NGINX Unit over the past year. He starts with general topics like how to receive announcements on the open source changes, the different code branches, and the version numbering scheme.

He continues with a deep dive into features completed during the beta period:

• Configuration persistence
• timeout parameter for applications
• HTTP keepalives
• home parameter for Python virtual environments
• Support for Python atexit handler
• processes object with prefork and dynamic process management
• Perl application module
• Ruby application module

He concludes with a review of changes made after the GA release of version 1.0:

• access_log parameter for basic access logging
• environment object for setting environment variables
• options object for managing php.ini configuration variables
• Support for command-line arguments for Go executables
• settings object for global configuration options
• HTTP settings for request body size and timeouts

To get the most from this session, review the changelog beforehand at unit.nginx.org/CHANGES.txt

In this session we will discuss how AWS and NGINX can complement each other to create highly scalable, high performance and secure web applications. We will cover the different ways that NGINX can integrate with AWS services such as NLB, Route53 and PrivateLink to add new layers of security and functionality to your high traffic website, streaming service or IOT system.

The modern-day data center is a scale-out, software-defined infrastructure where generic servers are used with software applications to create compute servers, storage servers and various appliance solutions. Today software load balancers are replacing purpose-built hardware/software appliances in order to distribute data around the scale-out environment.

Join Ahmet Houssein as he discusses how Solarflare’s XtremeScale technology with Universal Kernel Bypass accelerates NGINX performance, increasing QPS up to 4X compared to a kernel solution using a standard NIC and Linux kernel driver, while linearly scaling performance.

• NGINX+ support of QAT
• New additions or enhancements since last year
  • NGINX on VPP w/ QAT support
  • Async mode of NGINX release on Github
• Q&A

NGINX Advanced Load Balancing is a four‑hour class for system administrators, DevOps engineers, and architects who want to deepen their understanding of NGINX load balancing.

Developing NGINX Modules is a hands-on class that will give you the foundation you need to begin extending NGINX functionality with NGINX modules. The class begins with a discussion of when and why a new NGINX module might be the best solution. The instructors then guide you through the development process from the point of view of a first-time developer, covering common obstacles encountered and how to overcome them, with particular focus on the sites, blogs, and queries that are most helpful. Next, they'll dive into NGINX internals – the code that is NGINX – with an architectural overview, deep dives into how connections are handled, data types and structures, memory, module structure, and NGINX coding best practices.

Students then write a simple hello_world module, exploring the build process, dynamic vs. static modules, and how to specify the directives used to configure the module. After writing and executing tests for the module, students write additional simple modules for access, header filtering, and body filtering. Closing topics include the NGINX Certified Module program, best practices for module development, and available resources. The class wraps up with a panel discussion with the instructors – Valentin Bartenev, Roman Arutyunyan, and Aidan Carson.

Objectives After completing this class you will be able to:

• Describe NGINX internal architecture
• Explain core aspects of NGINX code in the context of module development
• Describe requirements for successful NGINX modules
• Get the resources you need to begin module development
• Create a simple content module
• Create a simple access module
• Create a simple header filter module
• Create a simple body filter module

Audience Developing NGINX Modules is for architects and developers who are interested in extending NGINX core functionality for specific business purposes.

Prerequisites Developing NGINX Modules is intended for developers and advanced administrators with prior development experience. C/C++ and systems programing is recommended. Basic knowledge of configuring, troubleshooting, and administering NGINX is highly advised. Although not a requirement, it's ideal for attendees to have already taken the NGINX Core course.

NGINX Advanced Caching is an four-hour course that builds on the discussion of caching in the NGINX Core course. It's a deep dive into how caching works, tools to managing your cache, techniques for tuning your cache, and methods for scaling your cache.