This talk was held at the Vert.x Meetup Amsterdam on 30-07-2014. The subject is on how to get a Vert.X cluster running in Docker containers running on CoreOS without any manual configuration.
Talk given at DomCode meetup in Utrecht (August 2014) on different frameworks to do asynchronous I/O y Python, with a strong focus on asyncio (PEP-3156).
This document provides a summary of a presentation about modern container orchestration with Kubernetes and CoreOS. It discusses what CoreOS is, how to easily set up CoreOS and Kubernetes, machine configuration, distributed configuration with etcd, scheduling and running workloads with Kubernetes, and service discovery using Kubernetes labels. It also briefly mentions CoreOS careers and continuous delivery of the OS.
The document discusses concepts related to event loops and concurrency in programming. It includes code snippets in Java showing the use of NIO selectors and channels for non-blocking I/O. Diagrams are shown illustrating reactor patterns and Vert.x modules deployed across multiple CPUs. The summary provides an overview of the main topics and techniques discussed in the technical document.
This document discusses socket programming in PHP. It begins with an overview of inter-process communication and network sockets. It then covers PHP streams and how they provide a generic interface for input and output. The document dives into details of socket programming in PHP using different extensions, covering topics like creating, binding, listening for, accepting, reading and writing sockets. It also discusses blocking, selecting sockets and websockets.
What Have Syscalls Done for you Lately?Docker, Inc.
If you've ever written any code - even just Hello World - you've used some syscalls. In this talk we'll explore what syscalls are, how they are used to set up containers, and how to make your deployment more secure at runtime by limiting the syscalls your containers can make thanks to seccomp and Linux security modules like AppArmor.
We'll also discuss how, if your architecture is broken into containerized microservices, this gives you a great opportunity to improve security by limiting what each container can do. This is where containerized microservices really shine over traditional monoliths from a security perspective - so it's helpful to know about if you're trying to convince your security team that containers are a good idea.
There will be lots of live demos!
A language for the Internet: Why JavaScript and Node.js is right for Internet...Tom Croucher
Node.js and JavaScript are well-suited for Internet applications because Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, capable of supporting many more concurrent connections than traditional server-side models like Apache. This event loop system allows Node.js to handle multiple requests simultaneously without blocking any specific request. It also minimizes memory usage so more requests can be served from fewer servers.
When it comes to networking inside Kubernetes, selecting the correct networking solution may be one of the most important decisions you may face. This is especially true if you are trying to run a Kubernetes cluster in production.
Therefore it's beneficial to have a good understanding of different CNI options out there and most importantly how these networking options are different from each other.
This presentation goes over packet by packet-level details of how the network plumbing is happening with different CNI plugins including, Flannel, Calico & Cilium.
Kotlin coroutines provide a way to write asynchronous and concurrent code using suspending functions and structured concurrency. Coroutines avoid callbacks and are lighter weight than threads. They allow suspending execution and resuming it later without blocking threads. This makes asynchronous code look synchronous and avoids issues like callback hell. Coroutines provide features like parallelism, cancellation, exception handling and context propagation to simplify concurrent programming.
This document provides an overview of the Tornado web server and summarizes its internals. It begins with an introduction to Tornado, describing it as a scalable, non-blocking web server and framework written in Python. It then outlines the main Tornado modules and discusses sockets, I/O monitoring using select, poll and epoll, and how Tornado sets up its server loop and handles requests.
vert.x 3.1 - be reactive on the JVM but not only in JavaClément Escoffier
Softshake 2015 Talk
Vert.x 3 is a toolkit to create reactive applications on the Java Virtual Machine. Vert.x 3 takes the JVM to new levels of reactive awesomeness: it lets you build scalable applications transparently distributed in Java, JavaScript, Ruby and Groovy. And, you don’t have to choose a single language, but mix them! This talk presents the key concepts of Vert.x and how you can use it to build your next application. This session explains how the simple model promoted by Vert.x enables the construction of concurrent, scalable and efficient micro-service based applications. Several examples are developed during the talk and demonstrates Vert.x features such as the distributed event bus, the high availability, the polyglot aspect and vert.x web.
Puppet User Group Presentation - 15 March 2012Walter Heck
The document discusses a puppet user group meeting in Kuala Lumpur, Malaysia. It introduces OlinData, a company that provides Puppet consulting and training services, and discusses how Puppet can help automate server configuration management compared to manual methods. Future plans are outlined for Puppet training in Southeast Asia through OlinData and an upcoming Puppet user group meetup.
The document describes Monkey, an open source HTTP server. It aims to be lightweight, fast, flexible and community-oriented while supporting embedded systems. Key features include HTTP/1.1, asynchronous sockets, Linux kernel support, multiple hardware architectures, and an indented configuration format. It uses a multi-layered architecture with worker threads for scheduling connections and tracking time. Plugins add functionality for logging, security, SSL, websockets and more. Benchmarks show it uses less memory than Nginx, Cherokee and Apache. Future plans include FastCGI, NoSQL support, URL rewriting and improved documentation. The project encourages community involvement through beta testing, artwork, documentation and coding.
The document summarizes how a Rails application handled 72 DDoS attacks per day. It discusses performance bottlenecks and various optimizations made, including tuning Linux TCP/IP settings, disabling connection tracking, using Imlib2 for image processing, throttling as needed, and spawning additional Unicorn workers. In the end, the team learned that Rails can scale with the right optimizations, as each application is different and not all recommendations from guides may apply.
Node.js is an asynchronous event-driven JavaScript runtime that aims to provide an easy way to build scalable network programs. It uses an event loop model that keeps slow operations from blocking other operations by executing callbacks asynchronously. This allows Node.js programs to handle multiple connections concurrently without creating new threads. Common uses of Node.js include building web servers, real-time applications, crawlers, and process monitoring tools. The document provides examples of using modules like HTTP, TCP, DNS, and file system modules to demonstrate Node.js's asynchronous and non-blocking I/O model.
The document discusses Node.js and asynchronous I/O. It explains that Node.js is an asynchronous event-driven JavaScript runtime that uses a single-threaded model with non-blocking I/O to handle high volumes of simultaneous connections efficiently. It also discusses how Node.js handles asynchronous operations using an event loop and callback functions instead of blocking operations.
Discovering Volume Plugins with Applications using Docker Toolbox and VirtualBoxClinton Kitson
There are right and wrong ways to use containers with persistent applications. Lucky for you, doing it the right way is much easier nowadays with Docker Volume Plugins. This talk will focus on doing some basic education including mostly live demos to show how you can take advantage of these new capabilities for expanding how you leverage containers. We will be going through a workflow that you can do yourself using boot2docker.
Building microservices with vert.x 3.0Agraj Mangal
Building Microservices is considered fad these days & with Vert.x 3.0 toolkit, it has never been simpler to build a Microservice in your favorite language
Vert.x – The problem of real-time data bindingAlex Derkach
As the popularity of any event-driven application increases, the number of concurrent connections may increase. Applications that employ thread-per-client architecture, frustrate scalability by exhausting a server’s memory with excessive allocations and by exhausting a server’s CPU with excessive context-switching. One of obvious solutions, is exorcising blocking operations from such applications. Vert.x is event driven and non blocking toolkit, which may help you to achive this goal. In this talk, we are going to cover it’s core features and develop a primitive application using WebSockets, RxJava and Vert.x.
Docker and Windows: The State of the UnionElton Stoneman
Session from Docker London, covering Docker on Windows:
- the Docker platform on Windows
- limitations and differences
- Dockerizing Windows applications
- running a hybrid swarm
This document discusses Docker and related technologies. It begins with introductions to Docker and concepts like Dockerfiles, images, and the Docker Hub. It then discusses tips for using Docker and demos linking containers and building images. Later it covers technologies that work with Docker like etcd for service discovery and fleet for cluster management. It emphasizes how Docker supports microservices and DevOps practices.
This document discusses Docker and CoreOS running on Raspberry Pi devices. It begins by providing background on Docker and virtual machines. It then discusses using Docker with Raspberry Pis, noting that Docker runs well on ARM-based devices like Raspberry Pi. It also discusses benefits of using the lightweight OS CoreOS with Docker, though CoreOS currently does not support ARM architectures. The document then covers potential issues with base images and importance of validation and verification for Docker images. It concludes by mentioning a live demo of Docker on Raspberry Pi and potential extensions like private repositories, web UIs, and Docker clusters.
O documento fornece uma introdução aos sistemas operacionais, com foco no GNU/Linux. Apresenta a história dos sistemas operacionais desde os primórdios até o desenvolvimento do Unix e do Linux. Discorre sobre as principais características e componentes de um sistema operacional, como o kernel e os gerenciadores de janelas. Fornece também uma visão geral sobre as principais distribuições Linux, programas, comandos de terminal e conceitos como processos, permissões e montagem de sistemas de arquivos.
Rocket is a new container runtime created by CoreOS as an alternative to Docker. It aims to address some perceived flaws in Docker's design by having composable components for building, running, and distributing containers. It uses a new App Container format and tools like rkt and actool for working with containers. The document demonstrates migrating a Docker container to Rocket and running it, showing Rocket's capabilities. It also discusses the initial reactions and debate surrounding Rocket's introduction.
Andrei Petcu: Rocket vs Docker: Battle for the Linux Container at I T.A.K.E. ...Mozaic Works
Rocket and Docker are competing platforms for Linux containers. Docker allows for easy reusability through commands like "docker pull" and "docker run" to download and run prebuilt container images. It also enables customization by allowing Dockerfiles to define layers for containers. Docker promotes immutability by making containers immutable once created. Rocket focuses on composability by making containers easily combinable and on security by implementing security at the container level through an App Container Spec. While Rocket and Docker compete in the container space, the article argues it is not a competition as both aim to advance container technologies.
The document discusses the promises and myths of new distributed computing platforms like Docker and Weave. It identifies 8 myths of how these new platforms position themselves, such as the idea that applications can be independent of the operating system or that platforms are better at designing apps than developers. The reality is that by "turning back the clock 30 years" to older distributed computing approaches, many of the skills and tools developers already use can apply when building apps on new platforms like Docker and Weave.
Some tools such as Chef and Jenkins are used by engineers in ops to great effect. Rarely though, a technology brings a paradigm to the masses.
Docker, like cloud virtualization is of this more rare breed.
Deploying Spring Boot applications with Docker (east bay cloud meetup dec 2014)Chris Richardson
This presentation describes how to deploy a Spring Boot-based microservice using Docker.
See http://plainoldobjects.com/2014/11/16/deploying-spring-boot-based-microservices-with-docker/
This document describes exploiting a use-after-free vulnerability called "Hearthstone" in VMware Workstation to escape from a virtual machine. It begins with background on VMware RPC and the fuzzing framework used. It then explains the Hearthstone vulnerability, how it allows information leakage, and how that leakage can be used to conduct an out-of-bounds write to achieve code execution on the host system. The presentation concludes with a demonstration of the exploitation process and takes questions.
Octo talk : docker multi-host networking Hervé Leclerc
This document summarizes Docker networking and the Docker libnetwork plugin. It discusses:
- Docker libnetwork implements the Container Network Model (CNM) with components like networks, endpoints, and network sandboxes.
- Network drivers like the bridge and overlay drivers are used to connect containers to networks and implement container isolation. The bridge driver uses Linux bridges while the overlay driver uses VXLAN tunnels for multi-host networks.
- Networking demonstrations show how containers on different Docker hosts can communicate over an overlay network using VXLAN tunnels even when isolated in separate network namespaces.
Architecting .NET Applications for Docker and Container Based DeploymentsBen Hall
This document discusses using Docker containers to deploy .NET applications. It covers running a basic ASP.NET application in a Docker container, linking multiple containers together, and using tools like Docker Gen and Consul for service discovery. It also explores possibilities for the future like running SQL Server and Visual Studio in containers, and how Docker can help close the gap between development and production. The overall message is that Docker is a useful tool for deploying many types of applications, including those built on .NET.
ContainerDayVietnam2016: Docker for JS DeveloperDocker-Hanoi
This document provides instructions for setting up a microservices architecture using Node.js, AngularJS, MongoDB, and Docker. It describes building API and CMS services using Express and Angular, respectively. It also covers orchestrating the services using Docker Compose and routing them through an Nginx gateway. Finally, it demonstrates deploying the system locally using Vagrant.
The Docker network overlay driver relies on several technologies: network namespaces, VXLAN, Netlink and a distributed key-value store. This talk will present each of these mechanisms one by one along with their userland tools and show hands-on how they interact together when setting up an overlay to connect containers.
The talk will continue with a demo showing how to build your own simple overlay using these technologies.
Docker Meetup: Docker Networking 1.11, by Madhu VenugopalMichelle Antebi
In this talk, Madhu Venugopal will present Docker Networking & Service Discovery features shipped in 1.11 and new Experimental Vlan network drivers introduced in 1.11.
Docker Meetup: Docker Networking 1.11 with Madhu VenugopalDocker, Inc.
In this talk, Madhu Venugopal will present Docker Networking & Service Discovery features shipped in 1.11 and new Experimental VLAN network drivers introduced in 1.11.
Docker 1.11 Meetup: Networking ShowcaseDocker, Inc.
Docker networking was introduced in Docker 1.9.0 and has continued to be improved upon and expanded. Key features introduced include support for multiple micro-segmented networks, built-in multihost networking using VXLAN, pluggable network plugins, and integration with Docker Swarm and Docker Compose. Later versions added additional capabilities like service discovery using embedded DNS, network load balancing, and experimental Macvlan and IPVlan drivers to connect containers to specific VLANs. Docker networking allows containers to be connected to different network types including default bridge networks, user-defined bridge networks, and overlay networks spanning multiple Docker hosts.
A presentation focused on the latest Storage API from Docker and integrating with an EMC {code} project called Rexray to provide container storage from EBS volumes.
This document summarizes Lucas Fontes' approach to deploying applications with Docker and Consul at Uken Studios, which has around 150 servers running 70 application servers and 40 databases. It outlines challenges with their previous deployment process and infrastructure, and describes how their new system addresses these using Docker for building and running applications, Consul for service discovery and configuration, and Consul Template to reload applications when configurations change. The workflow involves building Docker images, running containers securely, and releasing new versions by pushing images to a registry and notifying Consul to trigger reloads.
The document provides step-by-step instructions for building and running Intel DPDK sample applications on a test environment with 3 virtual machines connected by 10G NICs. It describes compiling and running the helloworld, L2 forwarding, and L3 forwarding applications, as well as using the pktgen tool for packet generation between VMs to test forwarding performance. Key steps include preparing the Linux kernel for DPDK, compiling applications, configuring ports and MAC addresses, and observing packet drops to identify performance bottlenecks.
Rick is a junior DevOps engineer tasked with building a scalable web application. He has been struggling with using just Docker due to difficulties with networking and managing multiple Docker hosts. The document introduces CoreOS as a solution, which uses Docker, etcd, fleet, and flannel to deploy and manage containers across a cluster of machines. Using the CoreOS platform, Rick's application can be automatically distributed across the cluster and discover services through etcd.
Warp 10 is a platform for ingesting, storing, and processing time series data. It uses WarpScript, a stack-based scripting language, to manipulate time series data. Developers can ingest sensor data via HTTP/WebSocket, run WarpScript programs to transform the data, and visualize results using widgets like Quantum. Warp 10 can integrate with other tools via APIs and libraries, and can be used for applications like IoT analytics, monitoring, and data processing.
XP Days Ukraine 2015 Talk http://xpdays.com.ua/programs/scaling-docker-with-kubernetes/
Kubernetes is an open source project to manage a cluster of Linux containers as a single system, managing and running Docker containers across multiple Docker hosts, offering co-location of containers, service discovery and replication control. It was started by Google and now it is supported by Microsoft, RedHat, IBM and Docker Inc amongst others.
Once you are using Docker containers the next question is how to scale and start containers across multiple Docker hosts, balancing the containers across them. Kubernetes also adds a higher level API to define how containers are logically grouped, allowing to define pools of containers, load balancing and affinity.
The document provides an overview of Docker networking options and access control. It discusses the default Linux bridge networking (Docker0), port mapping to access containers externally, using the host's network, and connecting containers via their networks. It also covers more advanced options like Open vSwitch for encapsulation and programmable networking. The document recommends using iptables and the --icc and --link flags for access control between containers and only allowing connected containers to communicate.
Docker orchestration using core os and ansible - Ansible IL 2015Leonid Mirsky
The last couple of years have seen an increasing interest in Docker and related technologies. One of these technologies is CoreOS, a new operating system built from the ground up for running Docker containers at scale.
In this talk we will learn about CoreOS main concepts and tools. We will get our hands dirty as we work together toward a goal of running a CoreOS cluster on AWS (using Ansible) and running docker containers on it.
The talk will conclude with a discussion on the place of Ansible (and configuration management tools in general) in the "next-generation" stack.
This document summarizes a presentation about running .NET applications on Docker containers. It discusses getting started with Docker, differences between Windows and Linux containers, building .NET and Node.js applications as Docker images, deploying containers to production environments, and the future of Docker integration with desktop applications and Microsoft technologies. Examples are provided of Dockerfile instructions for .NET and Node.js applications and using Docker Compose to run multi-container applications.
Docker Networking Meetup - Intro to Docker NetworkingDhananjay Sampath
We will have two parts to this meetup - in the first part we will cover the lay of the land for how networks are setup, configured and managed for containers and follow that up with a hands-on session.
6:00p-8:00p :
Introduction to Container Networking - DJ
Pipeworks - Jérôme Petazzoni
Docker + OpenvSwitch demo - Sriram
Handson Instructions: https://bitbucket.org/snrism/containet
Q&As: Online
Food: We will have pizzas and sodas.
Technical information: We will provide usb sticks with the required scripts. For this hands-on, only pre-req is to install "vagrant" in your laptop.
Similar to Vert.x clustering on Docker, CoreOS and ETCD (20)
seo proposal | Kiyado Innovations LLP pdfdiyakiyado
Crafting a compelling SEO proposal? Learn how to structure a winning SEO proposal template with essential elements and tips for client engagement. Elevate your SEO strategy with expert insights and examples
Tarun Gaur On Data Breaches and Privacy FearsTarun Gaur
Tarun Gaur On Data Breaches and Privacy Fears https://www.cbs19news.com/story/50764645/tarun-gaur-on-data-breaches-and-privacy-fears-navigating-the-minefield-of-modern-internet-safety
Megalive99 Situs Betting Online Gacor TerpercayaMegalive99
Megalive99 telah menetapkan standar tinggi untuk platform taruhan online. Berbagai macam permainan, desain ramah pengguna, dan transaksi aman menjadikannya pilihan utama para petaruh.
2. So what’s magne;c.io?
- Next-gen e-commerce platform aimed at the
enterprise market
- Integrate Continuous Delivery from the ground up
- Cocktail of PaaS, containers and micro services
3. CoreOS
- Just a Linux Distro
- Run apps in containers
- On the fly updating
- Fast boot times
- Systemd
images: coreos.com
4. ETCD
- Distributed key/value store
- Like a directory tree
- JSON/REST API
- Uses a Discovery URL
images: coreos.com
7. AWS / Vagrant / Bare Metal
CoreOS Box
Docker
JVM / Vert.x
priv. IP pub. IP
pub. IPpriv. IP
priv. IP pub. IP
bootstrapping the event bus:
Russian dolls
11. hey presto…
!
██╗ ██╗ █████╗ ███╗ ███╗██████╗
██║ ██║██╔══██╗████╗ ████║██╔══██╗
██║ ██║███████║██╔████╔██║██████╔╝
╚██╗ ██╔╝██╔══██║██║╚██╔╝██║██╔═══╝
╚████╔╝ ██║ ██║██║ ╚═╝ ██║██║
╚═══╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝
version 1.1
by magnetic.io
!
==> Starting cluster bootstrap...
==> info: Hazelcast port => 5701
==> info: Vertx Eventbus port => 5702
==> info: ETCD host => 10.0.42.1
==> info: ETCD port => 4001
==> info: ETCD base path => /vamp/bootstrap
==> info: Public IP => 172.17.8.103
==> info: Physical hostname => core-03
==> info: Container hostname => f9dc53532ff4
==> info: Vertx module to run => vamp-agent-0.1.0
==> info: Connecting to ETCD
==> info: Connected to ETCD at 10.0.42.1:4001
==> info: Vamp Bootstrap will try to cluster with started remote host 172.17.8.101
==> info: Starting Vamp Bootstrap with module vamp-agent-0.1.0
==> info: Waiting for Vamp Bootstrap to come online...
==> info: Vamp Bootstrap was started with PID 24 and public IP 172.17.8.103
12. coreos
Let’s boot a cluster on AWS!
vamp_loadbalancer
vamp_agent
coreos
vamp_agentvamp_agent
coreos
vamp_agentvamp_agent
coreos
vamp_agent
autoscale
REST
coreos
vamp_
controller
three AV zones
traffic
14. …the good parts
- Vert.x with Docker/CoreOS/ETCD is cool because:
- Size: in MB’s and in complexity
- Event bus makes distribution easy
- polyglot works nice with the idea of micro
services
15. …the bad parts
- Once it becomes complex, boilerplate rises
- ‘Actor-like’ maybe to coarse and without the
build in ‘reactive’ stuff which Akka has
- Not enough control / insight over the event bus
as a system