Tag Archives: bash

LVM – How to

Intro

LVM is a very powerful technology, and can really help the Sysadmin’s life.
However, this is something that we generally setup at the beginning (most of the time now it’s automatically setup during the installation process), and it’s well know… when we stop using something, we tend to forget how to use it.

This is why I’m writing this how to, mostly to keep track of the major features and commands, in case I will need them again in the future šŸ˜‰

Before proceeding, please digest the following journey of this poor physical device that gets abstracted up to usableĀ pieces.

 

 

Prepare partions

First of all, we need to find which device(s) we want to setup for LVM

fdisk -l

We can see 3 md devices, probably RAID devices. These are the ones that we are going to use for our LVM exercise.

Now, let’s create an LVM partition.

fdisk <device>Ā => n , p , 1 , (enter) , (enter) , t , 8e , w

Do the same for all the devices that you want to use for LVM. In my example, I’ve done this for /dev/md1, /dev/md2 and /dev/md3.

Shortcut (risky but quicker) šŸ™‚

All seems now good to go: we have Linux LVM partitions!

Time to start to configure LVM

Configure LVM

First of all, we need to make these Linux LVM partition able to be part of a group (vg). I always find tricky to remember the logic behind. Let’s imagine that the device itself now is just labelled “Linux LVM” but we need toĀ initiateĀ it in somehow.

pvcreate <dev>

Now theseĀ guys are ready to be part of a group. In this case a Virtual Group (vg).
Let’s check that it’s actually true:
pvs

Time to create a group with these devices (this could be done also with just a single device):

vgcreate <lvmgroupname> <dev> <dev> …

Now, let’s check again with pvs and vgs

Now pvs shows the VG group no longer empty but withĀ mylvmvg. And vgs tells us that the VG is about 14GB in size, fully free with no LV in it.

Good! Now, let’s make some LVs (logical volumes). These will be the newĀ “partitions/disks” that we will be actually able to format, mount and use! šŸ™‚

lvcreate -n <name> -L xGB <vg_group_name>

Some checks to verify:

A new LV appears inĀ vgs andĀ lvs shows the 2GB volume that we have created.

Let’s create another one, but this time, using the full remaining space (using -l 100%VGĀ option instead of -L xGB)

Magic!

Now, we have two devices, both ‘a’ -> active and ready to be formatted:
mkfs.ext4 <device>

I’ve done this for /dev/mylvmvg/part1 and /dev/mylvmvg/part2.

Let’s create the mount points and mount them:

As you can see, the devices are appearing now asĀ /dev/mapper/mylvmvg-partX. You can use eitherĀ /dev/mylvmvg/partX orĀ /dev/mapper/mylvmvg-partX. Theoretically, theĀ mapper one is recommended (my bad!).

Now the 2 devices are ready to be used as a typical disk/partition formatted with ext4 filesystem.

Resize Logical Volume

Now, imagine thatĀ part1 is too small, and you need more space. And luckily, yourĀ part2 volume has plenty. Is there any way to “steal” some space fromĀ part2Ā and give it toĀ part1?
Ooohh yesss! šŸ™‚

How?

  1. shrinkĀ part2 logical volumeĀ AND its filesystem
  2. expandĀ part1 logical volume AND its filesystem

Here the comments inline:

 

Move logical volume onto a new RAID array

Now, let’s imagine that one of the 3 initialĀ md devices are having problems, or simply we want to move on a faster/bigger raid array.
TheĀ magic of LVM is that we can actually do this with NO DOWNTIME!

How?

In this example we assume that a new /dev/md10 device is attached to our server and we want to removeĀ /dev/md2 device.

  1. We need to take the new device and go through all the previous steps:
    1. fdisk
    2. pvcreate
  2. After that, we need to add thisĀ initialised device in the existing volumeĀ group (vg)
  3. Move whatever is stored on the physical device
  4. Shrink the volume group
  5. Remove the device

Now where the new bits are starting:
pvmove, vgreduce, pvremove

 

In this example we have left LVM to decide where to put the data that was stored onĀ /dev/md2 device.
Just for reference, we could have specified the destination physical device (e.g. if we were thinking to remove more devices and make sure that the data was ending up on the new RAID and not sprat across the other disks):

Or, in case we just wanted to move a specific logical volume, let’s sayĀ part1

 

…happy LVM’ing! šŸ˜‰

Execute Linux command and kill the parent terminal without killing the process

This can be achieved using the command nohup

Source: http://stackoverflow.com/questions/13676457/how-can-i-put-the-current-running-linux-process-in-background

Screen – basic commands

 

Bash log redirect / stdout and stderr

 

Find files based on date/time

 

bash: /bin/rm: Argument list too long

 

Physically restart Sky router via Raspberry Pi

I have a Sky Hub router, theĀ SR102 (black).Ā Previously I had the white version as well.
Nice routers, pretty stable, but badly locked. You can change the SID of your wifi, change the password… not either sure if you can do a proper port forwarding. So… perfect for my mum,Ā but a pain for whoever wants a little bit of extra control.

I had already an ASUS RT-N16 with DD-WRT firmwareĀ so I used the DMZ function on the Sky router to have some sort of “link” of the public IP of my broadband directly on the WAN interface of the router. In this way it’s like that is my ASUS router that does the connection and I can play as freely as I want, without caring much about the Sky router.

However, it happens that sometimes you need to give a full reboot to the main Sky router. And maybe do this automatically or via command line/script. And here it’s when things are getting more complicated.

The Sky Hub router allows you to reboot it via HTTP. Using the DMZ anyway will bypass the router itself and forward all the requests to the ASUS router. Also, I have never liked the idea to expose my router management page to the Internet, but I rather prefer to connect via SSH on a Raspberry Pi and issue commands from the terminal (telnet/ssh).

So, beside my multiple attempts to find a way to curl the button on the page, I had to find an alternative way to makes this happen. Of course, it didn’t help either to call the Sky Helpline asking if there was a remote possibility to have telnet enabled.

After a bit of talks on Facebook with some friends, here the solution:Ā Remote Controlled Sockets with Pi-mote

Yes. If I can’t reboot fromĀ inside, let’s to that fromĀ outside!

The process was pretty straight forward.

First of all, I had to turn off my Raspberry Pi, and plug theĀ “little green piece of board” as mentioned in here

After that, I’ve turned the pi on again, and installed the required packages. Happily I found that there is now the python library available forĀ energenie, so I have installed them as well, making my life easier šŸ™‚

Once done, I have created these two basic script and I have run one a time, to configure the socket plugs.

Make sure to plug the ONE SOCKET PLUG A TIMEĀ and run the relative script.

You can find more information in the previous PDF, but these sockets learn who they are based on which commands they are receiving during the learning mode (enabling keeping the green button pressed for about 5 seconds when switched off). So if you run the first script with both plugs connected and in learning mode, they will do exactly the same, and unless you want to control two sockets at the same time, better to follow the instructions šŸ™‚

Script to configure the first socket:

 

Script to configure the second socket:

 

And now, my simple script to make… “the magic”: plugs.py

You can use this script to control any sockets (up to 4 – hardware limitation).

And here a bash wrapper (I’m not really good in python sorry) that calls plugs.py and restart the router:Ā restart_sky_router

 

Now, I can have my Nagios system to check for the speed as documented here and eventually issueĀ restart_sky_router script to see if it fixes the issue. Or simply be able to have a command to integrate in your scripts!

 

Check Sky Hub speed script

Bash script that extract the router speed.

 

This can be integrated in Nagios to send an alert if the speed drops.