systemd-nspawn command runs a command or OS in a lightweight namespace container
RouteFlow is an open source project to provide virtualized IP routing services over OpenFlow enabled hardware.
A typical RouteFlow use scenario is composed by an OpenFlow controller application (RFProxy), an independent RouteFlow server (RFServer), and a virtual network environment that reproduces the connectivity of a physical infrastructure and runs IP routing engines (e.g. Quagga).
The routing engines generate the forwarding information base (FIB) into the Linux routing tables according to the configured routing protocols (e.g., OSPF, BGP). In turn, the Linux IP and ARP tables are collected by RouteFlow client (RFClient) processes and then translated into OpenFlow tuples that are finally installed in the associated OpenFlow-enabled devices in the forwarding plane.
An opinionated LXC wrapper.
LXC, aka Linux Containers. In case you don't know what they are, it's basically virtual machines without emulating the hardware. In technical details, it's chroot on steroids, because the filesystem, processes and networking are separated from the host. More information here.
This technology is getting a lot of traction since ~2 years, because it allows people to create isolated environments very quickly, very cheaply. Fedora 21, for example, will have each application run in a different container. Deploying containers on AWS lets you build multi-tier architectures for cheap, etc etc. There are many applications.
I personally use them as "VMs" for my projects (each project gets a VM). And lxc-wrapper is there to help me with that. I think this is a common usage though, so I thought it was worth sharing.
You never hear anyone complain about having too many metrics, here's how you can use ansible and collectd to graph the memory usage of your containers.
=======
http://debmon.org/packages
10 billets de blogs sur LXC
It's with great pleasure that the LXC team is announcing the release of LXC 1.0!
This release is a significant milestone for us as it marks the first release we consider to be production ready. It features a wide variety of improvements to container security, a consistent set of tools, updated documentation and an API with multiple bindings.
It is often told that Linux Containers (LXC) are not secure. This was definitely true 3 years ago, but they got much better. Here is a quick overview of current challenges, as well as ways to improve ...
LXC (LinuX Containers) is an operating system-level virtualization method for running multiple isolated Linux systems (containers) on a single control host. This is extremely useful to quickly create a system in a sandbox for security or to avoid mess in the host during tests.
In this article, I will briefly explain how to install a Debian Wheezy based container inside a Debian Wheezy host. I will use libvirt for the network part.
LXC 1.0: Your first Ubuntu container [1/10]
LXC 1.0: Your second container [2/10]
LXC 1.0: Advanced container usage [3/10]
LXC 1.0: Some more advanced container usage [4/10]
LXC 1.0: Container storage [5/10]
LXC 1.0: Security features [6/10]
LXC 1.0: Unprivileged containers [7/10]
LXC 1.0: Scripting with the API [8/10]
LXC 1.0: GUI in containers [9/10]
LXC 1.0: Troubleshooting and debugging [10/10]
Synopsis
Linux Containers (LXC) are an operating system-level virtualization method for running multiple isolated server installs (containers) on a single control host. LXC does not provide a virtual machine, but rather provides a virtual environment that has its own process and network space. It is similar to a chroot, but offers much more isolation.
Table of Contents
- Linux Containers
1.1. Synopsis
1.2. This HOWTO - Kernel Setup
2.1. Configuration Options - Setup of the Controlling Host
3.1. Control group filesystem
3.2. Userspace tools - Container install
4.1. Bootstrap
4.2. Download existing
4.3. Using the lxc tools - Container definition setup
5.1. Configuration files
5.2. Container /dev - Container Creation and destruction
6.1. Creation
6.2. Destruction - Init setup
7.1. /etc/inittab
7.2. rc.sysinit replacement
7.3. /etc/inittab cleanup
7.4. other rc.d/runlevel cleanup
7.5. /etc/rc.d/runlevel cleanup can be skipped if you need a simple setup
7.6. rc.d script for starting/stopping containers - Notes
8.1. keychain behavior when running in a private pid namespace - Reference Documentation
- Useful Resources
- Related tools
Virtualization allows the creation of multiple virtual machines (VM) on top of an existing computer, each VM configured in a very specific way. All virtual machines run in parallel alongside the regular host applications, without affecting the host system. The type of virtualization I am currently using is Linux containers (LXC), a lightweight virtualization technology built into Linux kernel.
Linux containers (LXC) is a lightweight virtualization technology built into Linux kernel. In my previous article, Debian Virtualization: LXC Application Containers, I have detailed the steps to configure and run a simple application container using LXC. LXC application containers are very lean and consume strictly the resources the application requires. This is in sharp contrast with other virtualization technologies which are running a full Linux distribution in VM.
Linux containers (LXC) is a lightweight virtualization technology built into Linux kernel. Unlike other similar technologies, the virtual machines (VM) are driven without any overhead by the kernel already running on the computer. In VM you run only the processes you need, most of the time without even going through the regular SysV or Linux init. This means that memory is used very conservatively. These lightweight containers are sometimes called application containers, as opposed to distribution containers where you run a full distro starting with SysV/Linux init.
LXC is a userspace interface for the Linux kernel containment features.
Through a powerful API and simple tools, it lets Linux users easily create and manage system or application containers.
Exploitez les clones !
L'utilisation de machines virtuelles est devenu un impératif dans le cadre du développement agile de site Web.
Elle permet de monter des plateformes dédiées à un projet ou un test pour valider des choix technologiques, des orientations de design, faire du testing A/B, et ceux-ci rapidement, sans empiler des machines physiques et à coût quasi-nul.
Avec une bonne virtualisation, le cycle de vie du service est couvert de sa conception à son exploitation.
Si vous ne souhaitez ni supporter les mauvaises performances I/O des systèmes de virtualisations complets comme VMWare, Xen ou KVM, ni utiliser un noyau spécifique, LXC est la solution de virtualisation du moment.
Cet article vous présente comment créer une machine virtuelle LXC - LinuX Container - sur une plateforme Linux Ubuntu ou Debian like.
Interactive commandline tutorial
The best way to learn how Docker works is to use it!
This hands-on tutorial is 100% online, so you don't need to install a thing. In about 10-15 minutes you'll be familiar with the basic Docker commands.
(Très bien foutu)
One of the (many) things which are not yet entirely clear to me and to the people I speak with about this topic almost on daily basis is how the networking can be done and configured when using LXC. Hopefully the first blog post on this topic is going to shed some more light on this matter and hopefully it will inspire further posts on various other topics related to the containers.
Ce billet va tenter de résumer la manière dont j'utilise LXC pour créer et utiliser des maquettes de grande taille pour tester des choses (protocoles, logiciels, ...) ayant trait aux réseaux informatiques.
Table des matières
Table des matières
Pourquoi maquetter ?
Les avantages de LXC pour maquetter
Mettre des conteneurs LXC en réseau
Adressage
Rendre la maquette plus réaliste
Automatiser le tout
Preseed-file
Scripts
Commun
Créer
Lancer
Stopper
Détruire
Netem
Pingall