Drupal-vm: A VM for Drupal Development

Drupal VM is a VM for Drupal, built with Ansible.

Drupal VM makes building Drupal development environments quick and easy, and introduces developers to the wonderful world of Drupal development on virtual machines or Docker containers (instead of crufty old MAMP/WAMP-based development).

There are two ways you can use Drupal VM:

1. With Vagrant and VirtualBox.
2. With Docker.

The rest of this README assumes you're using Vagrant and VirtualBox (this is currently the most flexible and widely-used method of using Drupal VM). If you'd like to use Drupal VM with Docker, please read the Drupal VM Docker documentation.

Drupal VM installs the following on an Ubuntu 18.04 (by default) linux VM:

• Apache (or Nginx)
• PHP (configurable version)
• MySQL (or MariaDB, or PostgreSQL)
• Drupal 7, 8, or 9
• Optional:
  • Drupal Console
  • Drush
  • Varnish
  • Apache Solr
  • Elasticsearch
  • Node.js
  • Selenium, for testing your sites via Behat
  • Ruby
  • Memcached
  • Redis
  • SQLite
  • Blackfire, XHProf, or Tideways for profiling your code
  • XDebug, for debugging your code
  • Adminer, for accessing databases directly
  • MailHog, for catching and debugging email

It should take 5-10 minutes to build or rebuild the VM from scratch on a decent broadband connection.

Please read through the rest of this README and the Drupal VM documentation for help getting Drupal VM configured and integrated with your workflow.

Customizing the VM

There are a couple places where you can customize the VM for your needs:

• config.yml: Override any of the default VM configuration from default.config.yml; customize almost any aspect of any software installed in the VM (more about configuring Drupal VM.
• drupal.composer.json or drupal.make.yml: Contains configuration for the Drupal core version, modules, and patches that will be downloaded on Drupal's initial installation (you can build using Composer, Drush make, or your own codebase).

If you want to use Drupal 8 on the initial install, do the following:

1. Set drupal_major_version: 8 inside config.yml.
2. Set drupal_composer_project_package: "drupal/recommended-project:^8@dev" inside config.yml.

If you want to use Drupal 7 on the initial install, do the following:

1. Switch to using a Drush Make file.
2. Update the Drupal version and core inside your drupal.make.yml file.
3. Set drupal_major_version: 7 inside config.yml.

Quick Start Guide

This Quick Start Guide will help you quickly build a Drupal 9 site on the Drupal VM creating a new Composer project. You can also use Drupal VM with Composer, a Drush Make file, with a Local Drupal codebase, or even a Drupal multisite installation.

If you want to install a Drupal site locally with minimal fuss, just:

1. Install Vagrant and VirtualBox.
2. Download or clone this project to your workstation.
3. cd into this project directory and run vagrant up.

But Drupal VM allows you to build your site exactly how you like, using whatever tools you need, with almost infinite flexibility and customization!

1 - Install Vagrant and VirtualBox

Download and install Vagrant and VirtualBox.

You can also use an alternative provider like Parallels or VMware. (Parallels Desktop 11+ requires the "Pro" or "Business" edition and the Parallels Provider, and VMware requires the paid Vagrant VMware integration plugin).

Notes:

• For faster provisioning (macOS/Linux only): Install Ansible on your host machine, so Drupal VM can run the provisioning steps locally instead of inside the VM.
• For stability: Because every version of VirtualBox introduces changes to networking, for the best stability, you should install Vagrant's vbguest plugin: vagrant plugin install vagrant-vbguest.
• NFS on Linux: If NFS is not already installed on your host, you will need to install it to use the default NFS synced folder configuration. See nfs instructions for Linux
• Versions: Make sure you're running the latest releases of Vagrant, VirtualBox, and Ansible—as of 2020, Drupal VM recommends: Vagrant 2.2.x, VirtualBox 6.1.x, and Ansible 2.9.x

2 - Build the Virtual Machine

1. Download this project and put it wherever you want.
2. (Optional) Copy default.config.yml to config.yml and modify it to your liking.
3. Create a local directory where Drupal will be installed and configure the path to that directory in config.yml (local_path, inside vagrant_synced_folders).
4. Open Terminal, cd to this directory (containing the Vagrantfile and this README file).
5. Type in vagrant up, and let Vagrant do its magic.

Once the process is complete, you will have a Drupal codebase available inside the drupal/ directory of the project.

Note: If there are any errors during the course of running vagrant up, and it drops you back to your command prompt, just run vagrant provision to continue building the VM from where you left off. If there are still errors after doing this a few times, post an issue to this project's issue queue on GitHub with the error.

3 - Access the VM.

Open your browser and access http://drupalvm.test/. The default login for the admin account is admin for both the username and password.

Note: By default Drupal VM is configured to use 192.168.88.88 as its IP, if you're running multiple VM's the auto_network plugin (vagrant plugin install vagrant-auto_network) can help with IP address management if you set vagrant_ip to 0.0.0.0 inside config.yml.

Extra software/utilities

By default, this VM includes the extras listed in the config.yml option installed_extras, for example:

installed_extras:
  - adminer
  # - blackfire
  # - drupalconsole
  - drush
  # - elasticsearch
  # - java
  - mailhog
  [...]

If you don't want or need one or more of these extras, just delete them or comment them from the list. This is helpful if you want to reduce PHP memory usage or otherwise conserve system resources.

Using Drupal VM

Drupal VM is built to integrate with every developer's workflow. Many guides for using Drupal VM for common development tasks are available on the Drupal VM documentation site.

Updating Drupal VM

Drupal VM follows semantic versioning, which means your configuration should continue working (potentially with very minor modifications) throughout a major release cycle. Here is the process to follow when updating Drupal VM between minor releases:

1. Read through the release notes and add/modify config.yml variables mentioned therein.
2. Do a diff of your config.yml with the updated default.config.yml (e.g. curl https://raw.githubusercontent.com/geerlingguy/drupal-vm/master/default.config.yml | git diff --no-index config.yml -).
3. Run vagrant provision to provision the VM, incorporating all the latest changes.

For major version upgrades (e.g. 4.x.x to 5.x.x), it may be simpler to destroy the VM (vagrant destroy) then build a fresh new VM (vagrant up) using the new version of Drupal VM.

System Requirements

Drupal VM runs on almost any modern computer that can run VirtualBox and Vagrant, however for the best out-of-the-box experience, it's recommended you have a computer with at least:

• Intel Core processor with VT-x enabled
• At least 4 GB RAM (higher is better)
• An SSD (for greater speed with synced folders)

Other Notes

• To shut down the virtual machine, enter vagrant halt in the Terminal in the same folder that has the Vagrantfile. To destroy it completely (if you want to save a little disk space, or want to rebuild it from scratch with vagrant up again), type in vagrant destroy.
• To log into the virtual machine, enter vagrant ssh. You can also get the machine's SSH connection details with vagrant ssh-config.
• When you rebuild the VM (e.g. vagrant destroy and then another vagrant up), make sure you clear out the contents of the drupal folder on your host machine, or Drupal will return some errors when the VM is rebuilt (it won't reinstall Drupal cleanly).
• You can change the installed version of Drupal or drush, or any other configuration options, by editing the variables within config.yml.
• Find out more about local development with Vagrant + VirtualBox + Ansible in this presentation: Local Development Environments - Vagrant, VirtualBox and Ansible.
• Learn about how Ansible can accelerate your ability to innovate and manage your infrastructure by reading Ansible for DevOps.

Tests

To run basic integration tests using Docker and Molecule:

1. Install Docker.
2. Install Molecule: pip3 install ansible molecule[docker]
3. In this project directory, run: composer run-tests

The project's automated tests are run via GitHub Actions, and the more comprehensive test suite covers multiple Linux distributions and many different Drupal VM use cases and deployment techniques.

Documentation

Full Drupal VM documentation is available at http://docs.drupalvm.com/

Download Details:

Author: Geerlingguy
Source Code: https://github.com/geerlingguy/drupal-vm 
License: MIT license

#ansible #docker #cms #vagrant #developement 

Ansible examples using Vagrant to deploy to local VMs

Ansible Vagrant Examples

This repository contains a collection of example virtual machines running various applications. The VMs are created via Vagrant and provisioned via Ansible.

You can cd into any of the included directories and run vagrant up, and a generic Linux VM will be booted and configured in a few minutes. You just need to install Vagrant, VirtualBox, and Ansible. View the included README.md file in any of the subdirectories to find out more about the particular VM.

All of these examples use a combination of roles I've added to Ansible Galaxy, and were created to help demonstrate Ansible's simplicity and flexibility.

Read more about Ansible and how I use it to manage infrastructure in Ansible for DevOps, a book I've written.

VMs/Apps Currently Present

• Docker (docker - Docker container building and management (builds a simple LAMP stack).
• Drupal (drupal - LAMP/LEMP-based Content Management System)
• ELK (elk - This example has been moved to the Ansible for DevOps repository)
• GitLab (gitlab - Ruby-based GitHub-like Git web interface)
• Gogs (gogs - Go-based GitHub-like Git web interface)
• Jenkins (jenkins - Java-based Continuous Integration server)
• LAMP (lamp - Linux, Apache, MySQL, and PHP)
• LEMP (lemp - Linux Nginx, MySQL, and PHP-fpm)
• Munin (munin - Munin and munin-node monitoring server)
• Node.js (nodejs - Node.js-based API app using restify)
• Phergie (phergie - PHP IRC Bot)
• Rails (rails - Ruby on Rails demo app running on Passenger/Nginx)
• Apache Solr (solr - Java-based text search service)
• SonarQube (sonarqube - Java-based code quality analysis and review tool)
• SVN (svn - An SVN server using Apache for a web interface)
• Svn2Git (svn2git - A VM which includes KDE's Svn2Git for repository conversions)

Author Information

Created in 2014 by Jeff Geerling, author of Ansible for DevOps.

Download Details:

Author: Geerlingguy
Source Code: https://github.com/geerlingguy/ansible-vagrant-examples 
License: MIT license

#ansible #vagrant #ruby #docker 

Ansible-tuto: Ansible tutorial

Ansible tutorial

This tutorial presents Ansible step-by-step. You'll need to have a (virtual or physical) machine to act as an Ansible node. A Vagrant environment is provided for going through this tutorial.

Ansible is a configuration management software that lets you control and configure nodes from another machine. What makes it different from other management software is that Ansible uses (potentially existing) SSH infrastructure, while others (Chef, Puppet, ...) need a specific PKI infrastructure to be set up.

Ansible also emphasizes push mode, where configuration is pushed from a master machine (a master machine is only a machine where you can SSH to nodes from) to nodes, while most other CM typically do it the other way around (nodes pull their config at times from a master machine).

This mode is really interesting since you do not need to have a 'publicly' accessible 'master' to be able to configure remote nodes: it's the nodes that need to be accessible (we'll see later that 'hidden' nodes can pull their configuration too!), and most of the time they are.

This tutorial has been tested with Ansible 2.9.

We're also assuming you have a keypair in your ~/.ssh directory.

Quick start

• install Vagrant if you don't have it
• install ansible (preferably 2.10.5+ and using pip+virtualenv)
• vagrant up
• goto step-00

Complete explanations

Installing Ansible

The reference is the installation guide, but I strongly recommend the Using pip & virtualenv (higly recommended !) method.

Using pip & virtualenv (higly recommended !)

The best way to install Ansible (by far) is to use pip and virtual environments.

Using virtualenv will let you have multiple Ansible versions installed side by side, and test upgrades or use different versions in different projects. Also, by using a virtualenv, you won't pollute your system's python installation.

Check virtualenvwrapper for this. It makes managing virtualenvs very easy.

Under Ubuntu, installing virtualenv & virtualenvwrapper can be done like so:

sudo apt install python3-virtualenv virtualenvwrapper python3-pip
exec $SHELL

You can then create a virtualenv:

mkvirtualenv ansible-tuto
workon ansible-tuto

(mkvirtualenv usually switches you automatically to your newly created virtualenv, so here workon ansible-tuto is not strictly necessary, but lets be safe).

Then, install ansible via pip:

pip install ansible==2.7.1

(or use whatever version you want).

When you're done, you can deactivate your virtualenv to return to your system's python settings & modules:

deactivate

If you later want to return to your virtualenv:

workon ansible-tuto

Use lsvirtualenv to list all your virtual environments.

From source (if you want to hack on ansible source code)

Ansible devel branch is always usable, so we'll run straight from a git checkout. You might need to install git for this (sudo apt-get install git on Debian/Ubuntu).

git clone git://github.com/ansible/ansible.git
cd ./ansible

At this point, we can load the Ansible environment:

source ./hacking/env-setup

From a distribution package (discouraged)

sudo apt-get install ansible

From a built deb package (discouraged)

When running from an distribution package, this is absolutely not necessary. If you prefer running from an up to date Debian package, Ansible provides a make target to build it. You need a few packages to build the deb and few dependencies:

sudo apt-get install make fakeroot cdbs python-support python-yaml python-jinja2 python-paramiko python-crypto python-pip
git clone git://github.com/ansible/ansible.git
cd ./ansible
make deb
sudo dpkg -i ../ansible_x.y_all.deb (version may vary)

Cloning the tutorial

git clone https://github.com/leucos/ansible-tuto.git
cd ansible-tuto

Running the tutorials interactively with Docker

You can run the tutorials here interactively including a very simple setup with docker.

Check this repository for details.

Using Vagrant with the tutorial

It's highly recommended to use Vagrant to follow this tutorial. If you don't have it already, setting up should be quite easy and is described in step-00/README.md.

If you wish to proceed without Vagrant (not recommended!), go straight to step-01/README.md.

Contents

Terminology:

• command or action: ansible module executed in stand-alone mode. Intro in step-02.
• task: combines an action (a module and its arguments) with a name and optionally some other keywords (like looping directives).
• play: a yaml structure executing a list of roles or tasks over a list of hosts
• playbook: yaml file containing multiple plays. Intro in step-04.
• role: an organisational unit grouping tasks together in order to achieve something (install a piece of software for instance). Intro in step-12.

Just in case you want to skip to a specific step, here is a topic table of contents.

• 00. Vagrant Setup
• 01. Basic inventory
• 02. First modules and facts
• 03. Groups and variables
• 04. Playbooks
• 05. Playbooks, pushing files on nodes
• 06. Playbooks and failures
• 07. Playbook conditionals
• 08. Git module
• 09. Extending to several hosts
• 10. Templates
• 11. Variables again
• 12. Migrating to roles
• 13. Using tags (TBD)
• 14. Roles dependencies (TBD)
• 15. Debugging (TBD)
• 99. The end

Contributing

Thanks to all people who have contributed to this tutorial:

• Aladin Jaermann
• Alexis Gallagher
• Alice Ferrazzi
• Alice Pote
• Amit Jakubowicz
• Anonymous Contributor
• Arbab Nazar
• Atilla Mas
• Ben Visser
• Benny Wong
• Bernardo Vale
• Chris Schmitz
• Cyril Mouchel
• dalton
• Daniel Howard
• David Golden
• Davide Restivo
• Eric Corson
• Eugene Kalinin
• Ludovic Gasc
• Hartmut Goebel
• Jelly Robot
• Justin Garrison
• Karlo
• lenowac
• Marchenko Alexandr
• Maxim Zaitsev
• Michael B. Sumulong
• Mikhail Shavliuk
• mxxcon
• Patrick Pelletier
• Pierre-Gilles Levallois
• Ruud Kamphuis
• tkermode
• torenware
• Victor Boivie
• Yauheni Dakuka

(and sorry if I forgot anyone)

I've been using Ansible almost since its birth, but I learned a lot in the process of writing it. If you want to jump in, it's a great way to learn, feel free to add your contributions.

The chapters being written live in the writing branch.

If you have ideas on topics that would require a chapter, please open a PR.

I'm also open on pairing for writing chapters. Drop me a note if you're interested.

If you make changes or add chapters, please fill the test/expectations file and run the tests (test/run.sh). See the test/run.sh file for (a bit) more information.

When adding a new chapter (e.g. step-NN), please issue:

cd step-99
ln -sf ../step-NN/{hosts,roles,site.yml,group_vars,host_vars} .

For typos, grammar, etc... please send a PR for the master branch directly.

Thank you!

Download Details:

Author: leucos
Source Code: https://github.com/leucos/ansible-tuto 
License: View license

#ansible #vagrant #tutorial 

10 Popular Steps To Create Multiple Virtual Machines Using Vagrant

By now you must have seen how to install a single development environment (VM) using vagrant. In case you haven’t please refer to my previous blog before going through this one.

In this blog we are going to see how to create multiple VMs using vagrant. But before we start, we must understand the requirements where  we need to create multiple VMs of the same configuration.

Requirement 1: Hadoop is one of the cutting-edge technologies today and it can be used by creating a hadoop cluster. At times you do not require a full-fledged cluster, but can manage with two servers only. However, you will need at least three datanodes. In this case, you may use one server as Namenode (since namenode has be a high-end machine) and in the other server you can create 3 VMs and use them as 3 datanodes.

Requirement 2: You are working in a production environment where you are dealing with a big project. As all of us are aware that before we deploy the project on the live server, the project has to be developed on the development server and tested on the test server. These servers are of the same configuration. Hence, we may use vagrant to create these servers all together instead of building them individually.

There can be many other requirements where you may leverage this feature. I would encourage you to comment your requirement on this blog so that it can help others as well.

It is assumed that you have Vagrant and Virtual Box already installed. Now, let’s see how to create multiple VMs using vagrant:

Step 1: Open the terminal (Linux or Mac) or command prompt (Windows)

Step 2: Create a new directory for vagrant :

$ mkdir vagrant_multi_edureka
$ cd vagrant_multi_edureka

Step 3: Initialize a new VagrantFile.

$ vagrant init

Step 4: Install a vagrant box. We are using “chef/centos-6.5” for this blog. You can see the list of boxes here.

$ vagrant box add chef/centos-6.5

Step 5: Update the Vagrant File as below:

# This defines the version of vagrant
Vagrant.configure(2) do |config|
	# Specifying the box we wish to use
	config.vm.box = "chef/centos-6.5"
	# Adding Bridged Network Adapter
	config.vm.network "public_network"
	# Iterating the loop for three times
	(1..3).each do |i|
		# Defining VM properties
		config.vm.define "edureka_vm#{i}" do |node|
			# Specifying the provider as VirtualBox and naming the VM's
			config.vm.provider "virtualbox" do |node|
				# The VM will be named as edureka_vm{i}
				node.name = "edureka_vm#{i}"  
			end
		end
	end
end

Step 6: Let’s start the edureka_vms namely: edureka_vm1, edureka_vm2 and edureka_vm3:

$ vagrant up

Congratulations! You have created three VMs using single vagrant file. You must be wondering how to use it. You can access it using ssh.
You can connect the VMs using the below host and port number:

edureka_vm1        –>        Host : 127.0.0.1    |   Port  : 2222
edureka_vm2        –>        Host : 127.0.0.1    |   Port  : 2200
edureka_vm3        –>        Host : 127.0.0.1    |   Port  : 2201

Step 7: Download putty (windows shh client) from here. Run the application and connect to the VMs.

Step 8: You need to enter the username and password to login into the VM. It is same for all the three VMs. Please use the below credentials:

                                         Username : vagrant    |   Password : vagrant

Step 9: You need to log in to each VM separately using putty in order to access them.

Step 10: Finally, you need to understand if this fits your requirement or not. Accordingly you will understand how to use vagrant to get maximum benefit.

Got a question for us? Please mention it in the comments section and we will get back to you.

Related Posts:

Mystery Of Devops

Original article source at: https://www.edureka.co/

#steps #machine #vagrant 

Install Laravel 8.x on Win 10 with Homestead (VirtualBox)

Laravel is the most popular open-source PHP MVC-framework created by Taylor Otwell. The current version of Laravel is 8.x. You might be a fan of XAMPP for your Windows dev machine. However, in the development routine, you may occasionally hear the “works on my machine” excuse.

Homestead is the official Laravel package to help you resolve this awful moment by leverage the power of the virtual machine and the Vagrant automation script. So, all your teammates will be in the same environment all the time!

【Update 5 Apr 21: Now with Youtube Demo Video at the bottom!】

Please ensure the following software installed on your Windows:

• Git (Download  Link)
• VirtualBox (Download  Platform & Extension Pack)
• Vagrant (Download  Link)
• PuTTY (Download  Link)
• HeidiSQL (Download  Link)
• VS Code (Download  Link)

1. Git

Generally, just follow the installation wizard (accept the default options) and complete the installation.

For beginner, Nano editor is recommended.

You may notice that Git is not mentioned in the diagram above, but it is a crucial software behind your daily development routines.

1.1 Generate your SSH Key

Note: Skip this step, if you have created your SSH key-pair previously.

Use RSA algorithm, for better compatibilities across the different systems,

execute this command:

ssh-keygen -t rsa -b 4096 -C “your_email@example.com”

#laravel #php #developer #vagrant

Setting up MySQL root user with Ansible and Vagrant

In this example we are going to update MySQL root user’s password, grant all privileges for all hosts by using Ansible and Vagrant.

Structure

.
├── Vagrantfile
└── provisioning
    ├── host_vars
    │   └── mysql
    ├── hosts.yml
    ├── roles
    │   └── mysql
    │       ├── handlers
    │       │   └── main.yml
    │       └── tasks
    │           └── main.yml
    └── site.yml

#ansible #mysql #vagrant

Setting up Jenkins on Ubuntu with Vagrant

In this example we’re going to install Jenkins on Ubuntu 14.04, do basic configurations and access it on Internet with ngrok. The ngrok will be running on host machine though, not in vagrant box. Visit official Jenkins, installing Jenkins on Ubuntu and ngrok pages for more information. Jenkins requires a web server installed on your system so we’re going to use apache as the web server.

Apache server

I assume that you’ve already installed it and it is up an running. Mine is accessible via http://192.168.10.11 IP address. Make sure you can access it too via http://localhost or whatever it is set to.

#jenkins #linux #vagrant #ubuntu

Application deployment example with Jenkins

In this example, we’re going to manually deploy our application to web server. Process is simple so Jenkins will tell web server to pull our application repository from Github. See the detailed explanation below.

How it works

With the configurations below, you can:

• deploy a new copy of git repository and checkout into master branch by default.

• deploy a new copy of git repository and checkout into any branch you want.

• deploy any given previous git repository by providing a release number (Jenkins build number) and checkout into master branch.

• deploy any given previous git repository by providing a release number (Jenkins build number) and checkout into any branch.

By default the deployment process:

• checks out into master branch.

• deploy a new copy of git repository.

• keeps 10 copies of releases on the web server and plus 1 which is the latest deployed release.

• names the releases after build numbers.

Optionally, the deployment process allows us to:

• check out into any given branch by letting us to set the branch name in branch field of “Build with Parameters” menu.

• deploy any given previous git repository by letting us to set a release number (Jenkins build number) in release field of “Build with Parameters” menu.

#jenkins #vagrant

What is Vagrant? Why Vagrant is important in DevOps World?

Hello All,

In this tutorial, we all will learn complete vagrant in three different parts.

• Introduction of vagrant
• Why vagrant is used?
• Different commands used in vagrant
• Example — Provisioning using a simple bash script

Introduction of Vagrant -

A vagrant is a tool for building and managing virtual machine environments in a single workflow.

Vagrant is used to setting up one or more virtual machines by:

• Importing pre-made images (called “boxes”)
• Setting VM-specific settings (IP address, hostnames, port forwarding, memory, etc.)
• Running provisioning software like Ansible and SaltStack.

#coding #devops #vagrant

Installing Jenkins with Vagrantfile

If you use Vagrantfile below, your Jenkins server will be up and running in Ubuntu 14.04 environment. It will also be accessible via http://192.168.10.11:8080/ from the host OS.

Vagrantfile

## -*- mode: ruby -*-
## vi: set ft=ruby :

Vagrant.configure("2") do |config|
    config.vm.box = "ubuntu/trusty64"

    config.vm.define :jenkins do |jenkins_config|
        jenkins_config.vm.hostname = 'jenkins'
        jenkins_config.vm.network "private_network", ip: "192.168.10.11"
    end

    config.vm.provider :virtualbox do |virtualbox_config|
        virtualbox_config.name = "Jenkins - Ubuntu 14.04"
    end

    config.vm.provision :shell, path: "bootstrap.sh"

    config.vm.synced_folder "", "/var/www/html", nfs: true, mount_options: ["actimeo=2"]
end

#jenkins #vagrant

What is Configuration Management?

Configuration management is the process by which a company or organization defines and tracks the state of its infrastructural resources. Encapsulated in those resources are both physical hardware and software. It is a means to ensure that when changes are made to a system, those changes are tracked, geared toward the ultimate predefined criteria of what state should be.

Further, the automation of configuration management is integral to building and maintaining more complex systems. To understand the importance of configuration management in today’s complex technological ecosystem, it is useful to imagine what the inverse entails.

Without Configuration Management

Consider a web-based service that has an environment comprised of multiple server instances. Some servers are responsible for serving web traffic, others for load balancing, a database node, a caching node, and more. This web service has a single System Administrator responsible for maintaining these servers and the uptime of the application.

One day during a particularly high-traffic event, users begin to report occasional error codes from the service. The System Administrator begins troubleshooting and realizes that one of the web nodes is no longer serving traffic. While troubleshooting one of the unresponsive web nodes, the other web nodes in the system begin to overloaded with traffic. A domino effect ensues, and suddenly, users are unable to access the service at all.

The System Administrator realizes that the web node that went down first has filled its disk to capacity. They quickly remedy the issue, bringing it and the other web nodes back online, and everything begins running smoothly again. However, they notice that the disk on the original web node that initiated the cascading failure continues to fill up. After further investigation, the System Administrator determines that verbose logging for some of the services is enabled. This setting is determined to be the root cause of the servers disk full error. They adjust the system configuration to turn the feature off, and the high-traffic event continues without issue.

Usually, the verbose logging feature is enabled to troubleshoot an issue. The fact that it was not turned off resulted in downtime for the application. If the application had proper configuration management and automation in place, the web node’s desired state would have been enforced, and the incident likely would not have occurred.

#tutorials #ansible #ci/cd #code #container #developer #devops #git #linux #monitoring #nodes #parent #parent server #platform #tools #vagrant #virtualization #vmware

How To Setup Vagrant and Virtual Box for Ubuntu 20.04!!

What is Vagrant??

Vagrant is an open-source software product for building and maintaining portable virtual software development environments, e.g., for Virtual Box, KVM, Hyper-V, Docker containers, VMware, and AWS.

What is Virtual Box??

Oracle VM Virtual Box is a free and open-source hosted hypervisor for x86 virtualization, developed by Oracle Corporation. Created by Innotek, it was acquired by Sun Microsystems in 2008, which was, in turn, acquired by Oracle in 2010. Virtual Box can be installed on Windows, Mac-OS, Linux, Solaris, and Open Solaris.

#docker #kubernetes #virtualbox #virtualization #vagrant

Kubernetes Production Cluster with Vagrant and Virtualbox on Mac

For development purposes, it would be great to have a Kubernetes Production Cluster locally, and with this article, I am going through the basic setup in order to start using a good one.

Kubespray to the rescue

There are few open-source solutions to achieve the task of deploying Production-Ready Kubernetes clusters, but I selected Kubespray.

It comes with Ansible playbooks (deploy, upgrade, utils and extras) and with plenty of tests.

What is supposed to be already installed:

• Vagrant
• Virtualbox
• Python + Pip

#kubespray #virtualbox #kubernetes #production #vagrant

How To Setup Laravel In Docker Container Tutorial

How To Setup Laravel In Docker Container environment locally on your machine.  Laradock is well-known package in the Laravel community. I will use Laradoc library to show you how to prepare Docker Container and run the laravel application in it. Docker is different from Homestead. Homestead creates a virtual machine while Docker, on the other hand, is pretty much the same as Vagrant, it also gives you the complete development environment but on Virtual Containers instead of Virtual Machine. Since running a virtual Container is much faster than running a full Virtual Machine, LaraDock is much quicker than Homestead. Homestead is just a command line tool that helps you to initialize and to boot a Virtual Machine via Vagrant. Where you SSH into that machine and start coding.

What is Docker Container

Docker is a computer program that performs operating-system-level virtualization also known as containerization. Docker, Inc had developed it. Docker is an open platform for developers and sysadmins to build, ship, and run distributed applications, whether on laptops, data center VMs, or the cloud.

#laravel #docker #virtual machine #vagrant

Hashicorp Vagrant 101

Vagrant is a tool for managing pre-configured Virtual Machines (VM). The emphasis is on management; Vagrant doesn’t build them, it just manages VMs created by existing hypervisors such as VirtualBox. It simplifies the process of downloading VM images and configuring them.

Vagrant also allows you to package your own box with your own environment variables, softwares, … and distribute it to the others. This way, you save a lot of time for people who need to have your own exact environment to replicate your work.

After booting up your VM box, you can configure other tools you need on your VM through several provisioners such as the shell, Terraform, Chef and Ansible. In other words, Vagrant integrates Provisioner and VirtualBox to configure your desired environment.

Source: https://www.softqubes.com/blog/introduction-of-vagrant-development/

Install VirtualBox first

$ sudo apt-get install vagrant

Install Vagrant

Although you can use your package manager to install vagrant, I recommend downloading the Debian package from Vagrant website (here) and installing it directly.

#virtual-machine #101 #vagrant