1. This document provides instructions for creating a headless Ubuntu/XFCE container using Docker and Dockerfish.
2. It shows how to install Dockerfish, pull the Ubuntu image, create and run a container, install XFCE and VNC, and export the container configuration to a new reusable image.
3. Key steps include cloning the Dockerfish repo, pulling the Ubuntu image, running the container with XFCE and VNC installed, checking the container IP, and using Dockerfish to commit the container configuration to a new image called devel/headless-ubuntu-vnc.
The document provides steps to dockerize a WordPress application. It involves installing Docker, creating a Dockerfile to define the WordPress application environment, building a Docker image from the Dockerfile, running the image as a container and configuring WordPress. Key steps include creating a Dockerfile to install Apache, MySQL, PHP and WordPress, building an image from the Dockerfile, running the image as a container and mapping ports, and configuring WordPress inside the container.
Installing and running Postfix within a docker container from the command linedotCloud
This document provides instructions for installing and running Postfix within a Docker container from the command line. It describes starting a container from the base image, updating system packages, installing Postfix, committing the image, running a new container from the image to check that Postfix is installed, and pushing the image to the Docker registry.
Teamtalk - Cluster Computing Library for Pharo SmalltalkQuentin Plessis
Teamtalk is a simple library to execute Pharo Smalltalk code in a cluster of Pharo Smalltalk instances. MapReduce is also supported.
Based on Vert.x using the VerStix library.
https://github.com/quentinplessis/Teamtalk
This document provides instructions for installing various development tools on Mac OSX, including Xcode, command line tools, Homebrew, Ruby, Python, VirtualBox, Vagrant, Chef, and Ansible. It describes downloading and installing each tool, and in some cases providing additional configuration steps or notes on cleaning up existing installations. The overall purpose is to set up a standard development environment with common utilities.
Preparation study for Docker Event
Mulodo Open Study Group (MOSG) @Ho chi minh, Vietnam
http://www.meetup.com/Open-Study-Group-Saigon/events/229781420/
This fabric workshop aims to create a deploy tool using Fabric that can deploy code to servers defined in roles, show existing tags, change to a different tagged version, and remove tags. The agenda includes demonstrating local tasks, remote tasks using an Ansible inventory file, and functions for mkdir, cd, and uploading files. Fabric provides a simple way to automate operations across multiple servers.
The hype around Docker is big, but does Docker live up to it? What is that this new tool excites developers and operators in unison? In this talk I will show what makes Docker different and what the vision behind it is. I will also give some practical insights from using Docker in development and production and demonstrate why I started to “dockerize" everything.
The document provides steps to dockerize a WordPress application. It involves installing Docker, creating a Dockerfile to define the WordPress application environment, building a Docker image from the Dockerfile, running the image as a container and configuring WordPress. Key steps include creating a Dockerfile to install Apache, MySQL, PHP and WordPress, building an image from the Dockerfile, running the image as a container and mapping ports, and configuring WordPress inside the container.
Installing and running Postfix within a docker container from the command linedotCloud
This document provides instructions for installing and running Postfix within a Docker container from the command line. It describes starting a container from the base image, updating system packages, installing Postfix, committing the image, running a new container from the image to check that Postfix is installed, and pushing the image to the Docker registry.
Teamtalk - Cluster Computing Library for Pharo SmalltalkQuentin Plessis
Teamtalk is a simple library to execute Pharo Smalltalk code in a cluster of Pharo Smalltalk instances. MapReduce is also supported.
Based on Vert.x using the VerStix library.
https://github.com/quentinplessis/Teamtalk
This document provides instructions for installing various development tools on Mac OSX, including Xcode, command line tools, Homebrew, Ruby, Python, VirtualBox, Vagrant, Chef, and Ansible. It describes downloading and installing each tool, and in some cases providing additional configuration steps or notes on cleaning up existing installations. The overall purpose is to set up a standard development environment with common utilities.
Preparation study for Docker Event
Mulodo Open Study Group (MOSG) @Ho chi minh, Vietnam
http://www.meetup.com/Open-Study-Group-Saigon/events/229781420/
This fabric workshop aims to create a deploy tool using Fabric that can deploy code to servers defined in roles, show existing tags, change to a different tagged version, and remove tags. The agenda includes demonstrating local tasks, remote tasks using an Ansible inventory file, and functions for mkdir, cd, and uploading files. Fabric provides a simple way to automate operations across multiple servers.
The hype around Docker is big, but does Docker live up to it? What is that this new tool excites developers and operators in unison? In this talk I will show what makes Docker different and what the vision behind it is. I will also give some practical insights from using Docker in development and production and demonstrate why I started to “dockerize" everything.
How Puppet Enables the Use of Lightweight Virtualized Containers - PuppetConf...Puppet
The document summarizes how Puppet can be used to enable lightweight virtualized containers by configuring applications and their dependencies into immutable container images during the build process. It compares deploying a Jenkins application with LDAP authentication on virtual machines versus containers. It discusses challenges with service resources in containers and provides solutions like overriding service resources or using multi-process images with systemd to build immutable Puppet-configured application images.
The document discusses using Docker containers and Puppet to compartmentalize services running on a personal server. Previously, many services like Postfix, Dovecot, DNS, etc. were running on the server with no isolation. The approach taken was to define Puppet profiles for each service, build Docker containers from those profiles, and run the containers independently with their own isolated environments. This improves security, ease of development and deployment, and allows immutable infrastructure by replacing containers instead of changing server configurations. Challenges discussed include Docker bugs, inconsistent Debian packages, and future plans to add HAProxy and a container registry.
Vagrant allows users to define and configure lightweight virtual development environments. It uses VirtualBox to run virtual machines from a Vagrantfile configuration. The document discusses how Vagrant abstracts hardware, allows multiple operating systems to run concurrently on virtual hardware, and is limited by physical resources. It also outlines how in 3 lines users can download a base box, initialize a new Vagrant project, and boot the virtual machine. Key benefits of Vagrant include quick setup for new team members, ability to version control server configurations, and easy switching between projects.
This document discusses using Docker and Java on a Raspberry Pi. It provides instructions for installing Docker on a Raspberry Pi and creating Dockerfiles to run a Tomcat application container from a Java WAR file. It also discusses using Docker for continuous delivery by building a Docker image registry to version and distribute application containers.
Slides for my talk at the Blue4IT meeting in Utrecht. It shows you how to run everything in a Docker container. You can run the DTAP environment, the build environment and the development environment (including IDE) in Docker.
Slides for the Docker for Java Developers workshop at JavaLand in 2017. It covers building and running containers. It also covers running GUI applications in Docker and using the Docker registry.
Simplify and run your development environments with Vagrant on OpenStackB1 Systems GmbH
Here are the steps to resolve the network issue:
1. Create a new internal network (e.g. 192.168.0.0/24)
2. Create a new router
3. Add the PublicNetwork as the gateway for the router
4. Add the internal network as an interface to the router
This will allow instances on the internal network to get floating IPs from the PublicNetwork via the router. The original error indicates direct access to the external network is forbidden, so routing traffic through an internal network and router is required.
This document discusses deploying a Node.js application using Docker. It provides steps for setting up a development environment on a local machine, provisioning a Ubuntu server using Vagrant, installing Docker on the server, building a Docker image from the application code, and automatically rebuilding and deploying the Docker container on code pushes to a git repository hosted on the server. The automated deployment is achieved through a post-receive git hook that checks out the new code, builds a new Docker image tagged with the git commit hash, stops and removes any existing containers, and runs the new container exposing port 80.
Building and Testing from Scratch a Puppet Environment with Docker - PuppetCo...Puppet
This document discusses using Docker containers to build and test Puppet code. It describes setting up a Docker container to mimic a production environment by specifying hostname, custom facts, and operating system. Tests can be run on this container to validate Puppet code works as expected before deploying changes. Future enhancements proposed include supporting more operating systems and Puppet versions, linking multiple test nodes, and using an existing Puppet master.
The document provides instructions for installing Docker and Rally on Ubuntu Trusty 14.04. It includes adding Docker repositories, installing Docker, verifying the Docker installation, installing Rally within a Docker container, and setting up a Rally directory. Proxy configuration steps are also outlined for accessing repositories through a proxy server.
This document provides an agenda and overview for a presentation on Ansible. The agenda includes introductions of Ansible, its architecture and concepts, deployment, and deploying a Symfony2 app with Ansible. Key points about Ansible are that it is a Python-powered IT automation tool that is simple, secure, and efficient. It uses SSH to manage nodes without agents. The document also discusses Ansible features, requirements, versions, and common modules.
Gebruik dezelfde Docker container voor Java applicaties tijdens ontwikkelen e...NLJUG
The document discusses using Docker and Jenkins for continuous delivery. It describes how Docker can be used to automate environment provisioning and application deployment. It provides details on building Docker images for things like Sonar and Jenkins, and shows how to run, manage, and connect containers. The document emphasizes that Docker allows easily moving and running software anywhere, and promotes using it along with Jenkins to manage a continuous delivery pipeline.
The document discusses Python virtual environments (virtualenv) and the pip package manager. It introduces virtualenv and pip, explains why they are useful tools for isolating Python environments and managing packages, and provides exercises for creating virtual environments, using pip to install/uninstall packages, creating your own pip packages, and sharing packages on PyPI. The goal is to help users understand and learn to use these tools in 90 minutes.
Infrastructure testing with Jenkins, Puppet and Vagrant - Agile Testing Days ...Carlos Sanchez
Extend Continuous Integration to automatically test your infrastructure.
Continuous Integration can be extended to test deployments and production environments, in a Continuous Delivery cycle, using infrastructure-as-code tools like Puppet, allowing to manage multiple servers and their configurations, and test the infrastructure the same way continuous integration tools do with developers’ code.
Puppet is an infrastructure-as-code tool that allows easy and automated provisioning of servers, defining the packages, configuration, services, … in code. Enabling DevOps culture, tools like Puppet help drive Agile development all the way to operations and systems administration, and along with continuous integration tools like Jenkins, it is a key piece to accomplish repeatability and continuous delivery, automating the operations side during development, QA or production, and enabling testing of systems configuration.
Using Vagrant, a command line automation layer for VirtualBox, we can easily spin off virtual machines with the same configuration as production servers, run our test suite, and tear them down afterwards.
We will show how to set up automated testing of an application and associated infrastructure and configurations, creating on demand virtual machines for testing, as part of your continuous integration process.
Getting instantly up and running with Docker and SymfonyAndré Rømcke
A look into how you can start to use Docker today with ready made setup with php7, nginx, redis, blackfire and so on. How you may extend it, and integrating it into your continuous integration workflow, and how you can setup a continuous deployment workflow using for instance Travis-CI.
Quicklink: https://legacy.joind.in/19070
This document summarizes a presentation about the Conan package manager for C and C++ applications. It discusses popular C++ libraries that are commonly needed like Boost and Poco. It shows how Conan can be used to add these libraries as dependencies to a project without needing to build them manually. The document provides an example of using Conan to add Boost and Poco to a demo application that calculates an MD5 hash and validates an email address. It also gives an overview of how Conan works, including its package naming scheme, local caching of packages, and community around sharing packages on Bintray.
Title: Introduction to Docker
Abstract:
During the year since it’s inception, Docker have changed our perception of the OS-level Virtualization also called Containers.
At this workshop we will introduce the concept of Linux containers in general and Docker specifically. We will guide the participants through a practical exercise that will include use of various Docker commands and a setting up a functional Wordpress/MySQL system running in two containers and communication with each other using Serf
Topics:
Docker Installation (in case is missing)
Boot2Docker
Docker commands
- basic commands
- different types of containers
- Dockerfiles
Serf
Wordpress Exercise
- setting up Serf cluster
- deploying MySQL
- deploying Wordpress and connecting to MySQL
Prerequisites:
Working installation of Docker
On Mac - https://docs.docker.com/installation/mac/
On Windows - https://docs.docker.com/installation/windows/
Other Platforms - https://docs.docker.com/installation/#installation
The document discusses different approaches for installing OpenStack including using DevStack, writing deployment recipes, and installing from source. It notes that installing from source requires analyzing package dependencies and scripts, managing different versions of software and configurations, and dealing with problems like remote repository failures and hidden dependencies. While time-consuming, installing from source allows more flexibility and control over the installation than using packages. The document suggests that repackaging software or creating deployment images may be better approaches to reduce problems when installing OpenStack.
Conan is a C/C++ package manager that allows defining and consuming packages from source code or pre-compiled binaries. It supports dependency management, configuration, and testing of C/C++ projects. The document provides an example of using Conan to retrieve and link to the Poco networking library in a C++ project, and describes how to create, test, and publish Conan packages from source code.
This document provides instructions for a lab on using Docker to install and run containers. The objectives are to install Docker, create images and containers, launch applications in containers, and store and access data in containers. It outlines setting up Docker on Ubuntu, pulling existing images like Fedora and running containers from them. Specific steps look at running the "hello-world" container, installing wget in a Fedora container, and persisting data. The last section provides instructions for building a Docker image to run the OwnCloud application in a container, addressing aspects like installing the application, configuring network access, and persisting data and configuration.
How Puppet Enables the Use of Lightweight Virtualized Containers - PuppetConf...Puppet
The document summarizes how Puppet can be used to enable lightweight virtualized containers by configuring applications and their dependencies into immutable container images during the build process. It compares deploying a Jenkins application with LDAP authentication on virtual machines versus containers. It discusses challenges with service resources in containers and provides solutions like overriding service resources or using multi-process images with systemd to build immutable Puppet-configured application images.
The document discusses using Docker containers and Puppet to compartmentalize services running on a personal server. Previously, many services like Postfix, Dovecot, DNS, etc. were running on the server with no isolation. The approach taken was to define Puppet profiles for each service, build Docker containers from those profiles, and run the containers independently with their own isolated environments. This improves security, ease of development and deployment, and allows immutable infrastructure by replacing containers instead of changing server configurations. Challenges discussed include Docker bugs, inconsistent Debian packages, and future plans to add HAProxy and a container registry.
Vagrant allows users to define and configure lightweight virtual development environments. It uses VirtualBox to run virtual machines from a Vagrantfile configuration. The document discusses how Vagrant abstracts hardware, allows multiple operating systems to run concurrently on virtual hardware, and is limited by physical resources. It also outlines how in 3 lines users can download a base box, initialize a new Vagrant project, and boot the virtual machine. Key benefits of Vagrant include quick setup for new team members, ability to version control server configurations, and easy switching between projects.
This document discusses using Docker and Java on a Raspberry Pi. It provides instructions for installing Docker on a Raspberry Pi and creating Dockerfiles to run a Tomcat application container from a Java WAR file. It also discusses using Docker for continuous delivery by building a Docker image registry to version and distribute application containers.
Slides for my talk at the Blue4IT meeting in Utrecht. It shows you how to run everything in a Docker container. You can run the DTAP environment, the build environment and the development environment (including IDE) in Docker.
Slides for the Docker for Java Developers workshop at JavaLand in 2017. It covers building and running containers. It also covers running GUI applications in Docker and using the Docker registry.
Simplify and run your development environments with Vagrant on OpenStackB1 Systems GmbH
Here are the steps to resolve the network issue:
1. Create a new internal network (e.g. 192.168.0.0/24)
2. Create a new router
3. Add the PublicNetwork as the gateway for the router
4. Add the internal network as an interface to the router
This will allow instances on the internal network to get floating IPs from the PublicNetwork via the router. The original error indicates direct access to the external network is forbidden, so routing traffic through an internal network and router is required.
This document discusses deploying a Node.js application using Docker. It provides steps for setting up a development environment on a local machine, provisioning a Ubuntu server using Vagrant, installing Docker on the server, building a Docker image from the application code, and automatically rebuilding and deploying the Docker container on code pushes to a git repository hosted on the server. The automated deployment is achieved through a post-receive git hook that checks out the new code, builds a new Docker image tagged with the git commit hash, stops and removes any existing containers, and runs the new container exposing port 80.
Building and Testing from Scratch a Puppet Environment with Docker - PuppetCo...Puppet
This document discusses using Docker containers to build and test Puppet code. It describes setting up a Docker container to mimic a production environment by specifying hostname, custom facts, and operating system. Tests can be run on this container to validate Puppet code works as expected before deploying changes. Future enhancements proposed include supporting more operating systems and Puppet versions, linking multiple test nodes, and using an existing Puppet master.
The document provides instructions for installing Docker and Rally on Ubuntu Trusty 14.04. It includes adding Docker repositories, installing Docker, verifying the Docker installation, installing Rally within a Docker container, and setting up a Rally directory. Proxy configuration steps are also outlined for accessing repositories through a proxy server.
This document provides an agenda and overview for a presentation on Ansible. The agenda includes introductions of Ansible, its architecture and concepts, deployment, and deploying a Symfony2 app with Ansible. Key points about Ansible are that it is a Python-powered IT automation tool that is simple, secure, and efficient. It uses SSH to manage nodes without agents. The document also discusses Ansible features, requirements, versions, and common modules.
Gebruik dezelfde Docker container voor Java applicaties tijdens ontwikkelen e...NLJUG
The document discusses using Docker and Jenkins for continuous delivery. It describes how Docker can be used to automate environment provisioning and application deployment. It provides details on building Docker images for things like Sonar and Jenkins, and shows how to run, manage, and connect containers. The document emphasizes that Docker allows easily moving and running software anywhere, and promotes using it along with Jenkins to manage a continuous delivery pipeline.
The document discusses Python virtual environments (virtualenv) and the pip package manager. It introduces virtualenv and pip, explains why they are useful tools for isolating Python environments and managing packages, and provides exercises for creating virtual environments, using pip to install/uninstall packages, creating your own pip packages, and sharing packages on PyPI. The goal is to help users understand and learn to use these tools in 90 minutes.
Infrastructure testing with Jenkins, Puppet and Vagrant - Agile Testing Days ...Carlos Sanchez
Extend Continuous Integration to automatically test your infrastructure.
Continuous Integration can be extended to test deployments and production environments, in a Continuous Delivery cycle, using infrastructure-as-code tools like Puppet, allowing to manage multiple servers and their configurations, and test the infrastructure the same way continuous integration tools do with developers’ code.
Puppet is an infrastructure-as-code tool that allows easy and automated provisioning of servers, defining the packages, configuration, services, … in code. Enabling DevOps culture, tools like Puppet help drive Agile development all the way to operations and systems administration, and along with continuous integration tools like Jenkins, it is a key piece to accomplish repeatability and continuous delivery, automating the operations side during development, QA or production, and enabling testing of systems configuration.
Using Vagrant, a command line automation layer for VirtualBox, we can easily spin off virtual machines with the same configuration as production servers, run our test suite, and tear them down afterwards.
We will show how to set up automated testing of an application and associated infrastructure and configurations, creating on demand virtual machines for testing, as part of your continuous integration process.
Getting instantly up and running with Docker and SymfonyAndré Rømcke
A look into how you can start to use Docker today with ready made setup with php7, nginx, redis, blackfire and so on. How you may extend it, and integrating it into your continuous integration workflow, and how you can setup a continuous deployment workflow using for instance Travis-CI.
Quicklink: https://legacy.joind.in/19070
This document summarizes a presentation about the Conan package manager for C and C++ applications. It discusses popular C++ libraries that are commonly needed like Boost and Poco. It shows how Conan can be used to add these libraries as dependencies to a project without needing to build them manually. The document provides an example of using Conan to add Boost and Poco to a demo application that calculates an MD5 hash and validates an email address. It also gives an overview of how Conan works, including its package naming scheme, local caching of packages, and community around sharing packages on Bintray.
Title: Introduction to Docker
Abstract:
During the year since it’s inception, Docker have changed our perception of the OS-level Virtualization also called Containers.
At this workshop we will introduce the concept of Linux containers in general and Docker specifically. We will guide the participants through a practical exercise that will include use of various Docker commands and a setting up a functional Wordpress/MySQL system running in two containers and communication with each other using Serf
Topics:
Docker Installation (in case is missing)
Boot2Docker
Docker commands
- basic commands
- different types of containers
- Dockerfiles
Serf
Wordpress Exercise
- setting up Serf cluster
- deploying MySQL
- deploying Wordpress and connecting to MySQL
Prerequisites:
Working installation of Docker
On Mac - https://docs.docker.com/installation/mac/
On Windows - https://docs.docker.com/installation/windows/
Other Platforms - https://docs.docker.com/installation/#installation
The document discusses different approaches for installing OpenStack including using DevStack, writing deployment recipes, and installing from source. It notes that installing from source requires analyzing package dependencies and scripts, managing different versions of software and configurations, and dealing with problems like remote repository failures and hidden dependencies. While time-consuming, installing from source allows more flexibility and control over the installation than using packages. The document suggests that repackaging software or creating deployment images may be better approaches to reduce problems when installing OpenStack.
Conan is a C/C++ package manager that allows defining and consuming packages from source code or pre-compiled binaries. It supports dependency management, configuration, and testing of C/C++ projects. The document provides an example of using Conan to retrieve and link to the Poco networking library in a C++ project, and describes how to create, test, and publish Conan packages from source code.
This document provides instructions for a lab on using Docker to install and run containers. The objectives are to install Docker, create images and containers, launch applications in containers, and store and access data in containers. It outlines setting up Docker on Ubuntu, pulling existing images like Fedora and running containers from them. Specific steps look at running the "hello-world" container, installing wget in a Fedora container, and persisting data. The last section provides instructions for building a Docker image to run the OwnCloud application in a container, addressing aspects like installing the application, configuring network access, and persisting data and configuration.
The document provides instructions on Docker practice including prerequisites, basic Docker commands, running containers from images, committing container changes to new images, logging into Docker Hub and pushing images.
It begins with prerequisites of having Ubuntu 18.04 or higher and installing the latest Docker engine and Docker compose. It then explains that Docker runs processes in isolated containers and uses layered images.
The document demonstrates basic commands like docker version, docker images, docker pull, docker search, docker run, docker ps, docker stop, docker rm and docker rmi. It also shows how to commit container changes to a new image with docker commit, tag and push images to Docker Hub. Other topics covered include docker exec, docker save/load, docker
Hide your development environment and application in a containerJohan Janssen
Presentation from our session at the JAX conference in Mainz. It shows how to run your IDE (Eclipse, NetBeans, IntelliJ...) inside a Docker container. Next to that some best practices are mentioned like the Docker registry and Docker compose.
Puppet Camp Chicago 2014: Docker and Puppet: 1+1=3 (Intermediate)Puppet
This document discusses Docker and Puppet and how they can be used together. It describes how Puppet can be used to install and configure Docker on a system and then how Dockerfiles can be used to build container images. However, it notes that using Puppet to build container images directly is not recommended and describes alternatives like using Puppet during the build process to configure "golden images" and then deploying them. It suggests approaches like running services externally to containers and using data containers to optimize container usage.
It is a simple introduction to the containers world, starting from LXC to arrive to the Docker Platform.
The presentation is focused on the first steps in the docker environment and the scenarious from a developer point of view.
The Dockerfile Explosion and the Need for Higher Level Tools by Gareth RushgroveDocker, Inc.
Dockerfiles are great. They provide a zero-barrier-to-entry format for
describing a single Docker image which is immediately clear to anyone
reading them. But with that simplicity comes problems that become
apparent as your adoption of Docker gathers pace.
* Dockerfiles can inherit from other docker images, but images are not
Dockerfiles
* Dockerfile provides no built-in mechanism for creating abstractions,
so as usage grows identical or similar instructions can be duplicated
across many files
* The Docker APi exposes a build endpoint, but the API is very course,
taking Dockerfile as the transport rather than exposing the individual
instructions
* Dockerfiles are just that, files. So they can come from anywhere
The one layer per line in a Dockerfile limitation can lead to an
explosion of layers, which fail to take advantage of the promised
space and performance benefits.
This document discusses Docker, including:
1. Docker is a platform for running and managing Linux containers that provides operating-system-level virtualization without the overhead of traditional virtual machines.
2. Key Docker concepts include images (immutable templates for containers), containers (running instances of images that have mutable state), and layers (the building blocks of images).
3. Publishing Docker images to registries allows them to be shared and reused across different systems. Volumes and networking allow containers to share filesystems and communicate.
This document discusses Docker and provides an introduction and overview. It introduces Docker concepts like Dockerfiles, commands, linking containers, volumes, port mapping and registries. It also discusses tools that can be used with Docker like Fig, Baseimage, Boot2Docker and Flynn. The document provides examples of Dockerfiles, commands and how to build, run, link and manage containers.
JDO 2019: Tips and Tricks from Docker Captain - Łukasz LachPROIDEA
The document provides tips and tricks for using Docker including:
1) Installing Docker on Linux in an easy way allowing choice of channel and version.
2) Setting up a local Docker Hub mirror for caching and revalidating images.
3) Using docker inspect to find containers that exited with non-zero codes or show commands for running containers.
4) Organizing docker-compose files with extensions, environment variables, anchors and aliases for well structured services.
This document provides instructions for pulling and running Docker containers for common applications like Nginx, MySQL, WordPress, PostgreSQL, Redis, and GitLab. It demonstrates how to pull base images, define Dockerfiles to customize images, run containers with links and ports, and mount volumes to persist data outside containers.
Dockerizing Symfony Applications - Symfony Live Berlin 2014D
This document discusses Dockerizing Symfony applications. It introduces Docker containers as a lightweight virtualization method using Linux namespaces and union filesystems. It then demonstrates how to containerize the components of a sample Symfony app - Redis, PHP-FPM, Nginx - connecting them using Docker links and volumes. Fig is introduced as a tool to define and run multi-container Docker environments using a YAML configuration file, making management of the Symfony app containers easier. Hosting challenges are mentioned along with an invitation to join Giantswarm's private beta for container management.
Docker is an open platform for developing, shipping, and running applications. It aims to solve the problem of maintaining different application versions across multiple platforms and servers. Docker allows applications to be packaged into standardized units called containers that contain all their dependencies so they can run reliably from one computing environment to another. Containers operate much more efficiently at runtime than virtual machines, using less memory and CPU resources. Docker images provide a lightweight template for creating containers which bundle application code and dependencies. This allows applications to be easily deployed and scaled across multiple machines.
Docker allows applications and their dependencies to be packaged into standardized units called containers that can run on any computing environment regardless of the underlying infrastructure. Containers leverage and share the host operating system's kernel to run as isolated processes, which improves performance and reduces overhead compared to virtual machines. Dockerfiles define the build instructions for container images, while Docker Compose allows defining and running multi-container applications with a single configuration file.
The Docker "Gauntlet" - Introduction, Ecosystem, Deployment, OrchestrationErica Windisch
This document summarizes Docker's growth over 15 months, including its community size, downloads, projects on GitHub, enterprise support offerings, and the Docker platform which includes the Docker Engine, Docker Hub, and partnerships. It also provides overviews of key Docker technologies like libcontainer, libchan, libswarm, and how images work in Docker.
This document provides instructions for installing various developer tools including Git, Vim, Java, Tomcat, Maven, and Psi Probe on Linux, Mac OSX, and Windows. It then outlines 3 homework assignments: 1) creating a basic Git repository, 2) forking and cloning a provided repository, adding a feature, resolving conflicts, and deploying the application, and 3) using Psi Probe to manage Tomcat web applications. Step-by-step instructions are provided for completing each task along with explanations of commands used.
This document discusses Docker, an open source project that automates the deployment of applications inside software containers. It begins by describing common problems in application deployment and how virtual machines address some issues but introduce overhead. It then summarizes the history and rapid growth of Docker since its launch in 2013. The rest of the document dives into technical aspects of Docker like how images and containers work, comparisons to virtual machines, security considerations, the Docker workflow, and how Docker relates to DevOps and continuous delivery practices.
Docker enables software developers to package applications and all dependencies so they can run unchanged anywhere. It allows system administrators to simplify application deployment, easily scale resources up or down, and isolate processes. Docker uses Linux technologies like namespaces, control groups, layered filesystems, and LXC to virtualize operating systems and run containers. Users install Docker Engine, use Dockerfiles to build images from which containers are launched, and manage machines with Docker Machine.
This document provides instructions on installing and using Docker on Linux (Ubuntu) and Windows. It discusses installing Docker on Ubuntu, basic Docker commands like images, ps, pull, run options for ports, volumes, and other commands. For Windows, it recommends using Docker Toolbox which includes Docker Machine, Engine, Compose and Kitematic GUI. It also covers installing the newer Docker for Windows which requires Windows 10 Pro/Enterprise with Hyper-V enabled.
1. How to build a headless Ubuntu / XFCE with Docker & Dockerfish
Make sure you have Docker installed first and foremost.
Getting started
This tutorial demonstrates the ease of use of my tool Dockerfish which i coded from the ground up in pure Ruby
it requires no gems so there is no messing about.
I also showyou then how make a image from your containerwith ease also.
All you have todo is have git installed and most developers have it installed as a no brainer.
if not apt-get install git for Ubuntu / Debian or yum install git for Centos / Fedora etc ...
cd into the folder of your choice to download into then.
git clone https://github.com/puppetpies/DockerFish-CLI.git
Check if docker is running
systemctl status docker.service
docker.service - DockerApplicationContainer Engine
Loaded: loaded(/usr/lib/systemd/system/docker.service; enabled)
Active: active (running) since Fri 2015-06-26 10:21:28BST; 46minago
Docs: http://docs.docker.io
Process: 786 ExecStartPre=/usr/bin/mount --make-rprivate/ (code=exited, status=0/SUCCESS)
Main PID: 792 (docker)
CGroup: /system.slice/docker.service
792 /usr/bin/docker --api-enable-cors=true -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock -d
Makingsure the APIis enabledyour docker.service ExecStart lineshouldlooklike this.
-H tcp://0.0.0.0:2375 - Youmay want torestrict this to certaininterface/ ip address as this what DockerFishwill access the API via.
cat /etc/systemd/system/multi-user.target.wants/docker.service
[Unit]
Description=DockerApplicationContainer Engine
Documentation=http://docs.docker.io
After=network.target
[Service]
ExecStartPre=/usr/bin/mount --make-rprivate /
ExecStart=/usr/bin/docker--api-enable-cors=true -H tcp://0.0.0.0:2375-H unix:///var/run/docker.sock -d
[Install]
WantedBy=multi-user.target
If you have had to make changes to this file then do the below.
systemctl daemon-reload
Then restart Docker where convieniant.
systemctl restart docker.service
2. Now check if Docker has started up correctly systemctl status docker.service if all is well lets download Ubuntu.
docker pull ubuntu
This may take sometime but its worth the wait.
Introduction to Dockerfish
Make yourdockerfish.rb executable
chmod 755 dockerfish.rb
symlink to /usr/bin # You need root for this and optional
ln -s dockerfish.rb /usr/bin/dockerfish
./dockerfish.rb
Welcome toDockerFishVersion 0.1
---------------------------------
Interactive CLIDocker Interface
[] |
|
,|.
,|/.
,' .V. `.
/ . . /_`
|@)| . . |(@|
,-._ `._'; . :`_,'_,-.
'-- `- /,-===-. /-' --`
(---- _| ||___|| |_ ----)
`._,-' `-.-' / `-._,'
`-.___,-' ap[]
TIPS: Please note ContainerId's / Names are interchangeable
Youcan also use short ContainerId's as longas there is a unique match
Start with Docker API Enabled: /usr/bin/docker --api-enable-cors=true -H tcp://127.0.0.1:2375 -H unix:///var/run/docker.sock -d
Add a symlink ln -s /home/brian/Projects/DockerFish/dockerfish.rb/usr/bin/dockerfish
--help # For more information
Enjoy!
Coded by Brian Hood
Server Info:
{"ApiVersion"=>"1.18",
"Arch"=>"amd64",
"GitCommit"=>"a61716e",
"GoVersion"=>"go1.4.2",
"KernelVersion"=>"3.14.5-1-ARCH",
"Os"=>"linux",
"Version"=>"1.5.0-dev"}
DockerFish> 1
List of DockerImages
=====================
Created: 2015-06-12 16:32:30 Id: 6d4946999d4fb403f4 Image: ["ubuntu:latest"] Size: 8B VirtualSize: 179.563MB
You now have the latest Ubuntu image at your finger tips great so what now ?
The first step is press 6 and hit enter.
3. 6) Create Container from Image
Enter Image touse> ubuntu:latest
Example: name orname1,name2,name3
Enter Container name(s)> ubuntu-xfce-headless
{
"Hostname":"ubuntu-xfce-headless",
"User":"",
"Memory":0,
"MemorySwap":0,
"CpuShares":0,
"AttachStdin":true,
"AttachStdout":true,
"AttachStderr":true,
"PortSpecs":null,
"Tty":true,
"OpenStdin":true,
"StdinOnce":true,
"Env":null,
"Cmd":[
"/bin/bash"
],
"Dns":null,
"Image":"ubuntu:latest",
"VolumesFrom":"",
"WorkingDir":"",
"HostConfig": {
"NetworkMode": "bridge",
"Devices": []
}
}
ContainerCreationSuccessfull
DockerFish> 2
List of DockerContainers
=========================
Command: /bin/bash ContainerId: 5073abe5f5c9 Image: ubuntu:latest Names: ["/ubuntu-xfce-headless"] Status:
Ok lets start up your container.
Press 3
DockerFish> 3
Enter Container to Start> ubuntu-xfce-headless
StartingContainer ubuntu-xfce-headless
Start Successfull
DockerFish> 2
List of DockerContainers
=========================
Command: /bin/bash ContainerId: 5073abe5f5c9 Image: ubuntu:latest Names: ["/ubuntu-xfce-headless"] Status: Up 48 seconds
Was it really that easy to yes in short now you just have todo the configuration in the next step.
Build your machine from scratch
Startup and Terminal
To attach to your docker instance run the folllowing.
docker attach ubuntu-xfce-headless
4. Then hit enter again to enter the container.
[brian@orville ~]$dockerattachubuntu-xfce-headless
root@ubuntu-xfce-headless:/# apt-get update
Ign http://archive.ubuntu.comtrustyInRelease
Ign http://archive.ubuntu.comtrusty-updates InRelease
Ign http://archive.ubuntu.comtrusty-securityInRelease
Hit http://archive.ubuntu.com trusty Release.gpg
Get:1 http://archive.ubuntu.com trusty-updates Release.gpg[933 B]
Get:2 http://archive.ubuntu.com trusty-securityRelease.gpg[933 B]
-- OMITTED --
Ok so youobtainedthe latest Ubunturepository dataif youdon’t knowwhat the means don’t worry.
Next downloadXFCE4
root@ubuntu-xfce-headless:/# apt-get install xfce4xvfbx11vnc
Readingpackage lists... Done
Building dependency tree
Readingstate information... Done
The followingextra packages will be installed:
-- OMITTED LOTSOF PACKAGES--
2 upgraded, 384 newly installed, 0 toremove and9 not upgraded.
Needto get 94.4 MB ofarchives.
After this operation,378MB of additional disk space will be used.
Do youwant to continue? [Y/n]
Press Y enter and sit back and relax read a book etc ...
Setup VNC / Xvfb
root@ubuntu-xfce-headless:/# mkdir ~/.vnc
root@ubuntu-xfce-headless:/# x11vnc -storepasswdletmein ~/.vnc/passwd
root@ubuntu-xfce-headless:/# Xvfb:1 -extensionGLX -screen0 1024x780x24 &
root@ubuntu-xfce-headless:/# DISPLAY=:1 /usr/bin/xfce4-session&
root@ubuntu-xfce-headless:/# x11vnc -usepw-forever-display:1 &
cat > start_session.sh
Xvfb:1 -extensionGLX -screen0 1024x780x24&
sleep 2
DISPLAY=:1 /usr/bin/xfce4-session &
sleep 2
x11vnc-usepw-forever -display:1 &
Press CTRL+C
chmod755 start_session.sh
When youstart yourDocker container youcan nowjust go.
./start_session.sh
See what your DockercontainerIP is.
root@ubuntu-xfce-headless:/# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu65536qdisc noqueue state UNKNOWN group default
link/loopback00:00:00:00:00:00brd00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft foreverpreferred_lft forever
inet6 ::1/128scope host
valid_lft foreverpreferred_lft forever
5: eth0: <BROADCAST,UP,LOWER_UP> mtu1500 qdisc noqueue state UP group default
link/ether 02:42:ac:11:00:01brdff:ff:ff:ff:ff:ff
inet 172.17.0.1/16scopeglobal eth0
5. valid_lft foreverpreferred_lft forever
inet6 fe80::42:acff:fe11:1/64 scope link
valid_lft foreverpreferred_lft forever
Install a VNC Viewer like tigervnc on your host OS and connect to 172.17.0.1:0 this will
default to port 5900 using display port 0
Everything now working !
I recommend that you go into yoursettings in XFCE and configure the appearance as i had no icons until i
selected Tango from the icons menu.
Ok now as promised you have your Ubuntu with XFCE running underDocker.
Now lets make this container into its own Image so i can make as many of these as i want the question is how.
Thats easy.
First detach from your
root@ubuntu-xfce-headless:/# exit
Go back to your Dockerfish terminal.
DockerFish> 2
List of DockerContainers
=========================
Command: /bin/bash ContainerId: 5073abe5f5c9 Image: ubuntu:latest Names: ["/ubuntu-xfce-headless"] Status: Exited(0)
About a minute ago
You can see that it has exited which you need to create a image from it.
DockerFish> 15
Enter Container to Image> ubuntu-xfce-headless
Enter your commit comment important> UbuntuXFCE Headless
Enter your Repositoryname> devel/headless-ubuntu-vnc
Image Commit Successfull
How do i check if it worked ?
DockerFish> 1
List of DockerImages
=====================
Created: 2015-06-26 13:14:16 Id: 97a9b89d37cf63b41e Image: ["devel/headless-ubuntu-vnc:latest"] Size: 501.381MB
VirtualSize: 680.944MB
Nowyou’ve createdyour image your free tocustomize it by makingmore containers andmakingtheminto images.
Enjoy !
Brian Hood