Brendan Gregg made an unusual discovery, shouting a HD produces pikes of latency. We’ll see sound proof data centers now? Another point to solid-state drivers.
[youtube]tDacjrSCeq4[/youtube]
I wonder if playing loud music near my computer makes IO slower.
In this demo Roman Strobl shows the new functionality available from OpenSolaris 2008.11 . Time Slider allows users get instant rollback and point in time snapshots. This is possible the thought the ZFS Snapshots and now can be easily used by users thought the Time Slider in the Gnome interface.
More about news functionalities in OpenSolaris 2008.11 in the live demo “What’s new in OpenSolaris 2008.111” also with Roman.
Em Outubro eu fiz mais duas apresentações na FIC, durante sua VII Semana de Tecnologia da Informação.
Downloads:
A primeira apresentação foi sobre o NetBeans onde eu pude mostrar as funcionalidades básicas da plataforma e também mostrar na prática, ao vivo :D, a IDE em funcionamento e tirar várias dúvidas. Foi muito bom porque muitos viram funcionalidades do NetBeans que eles não sabiam que existiam. Eu tenho que fazer isso mais vezes.
O retorno dessa apresentação foi muito boa e os alunos da FIC demonstraram um imenso interesse em conhecer e aprender mais sobre o NetBeans. Podem contar comigo e com o CEJUG.
Veja também o álbum de fotos desta apresentação e fique atento esse mês para o lançamento do NetBeans 6.5 versão final.
O outra apresentação foi sobre OpenSolaris e Software/Cultura Livre. Pudemos conversar um pouco sobre Creative Commons, movimentos de Software Livre e na parte técnica, OpenSolaris com foco na administração de volumes com ZFS.
Os slides que eu usei foram os mesmos do Software Freedom Day. Para quem quiser rever os vÃdeos promocionais sobre Creative Commons, são eles:
Veja também o álbum de fotos da apresentação.
Também foi criado o OSUM (Open Source University Meetup) da FIC. É o http://osum.sun.com/group/fic. Se você é da FIC, não deixe de entrar. Já está se tornando um dos OSUMs mais ativos do estado.
Take a look in this interesting post of Dan MacAskill, CEO of SmugMug, about his experiences on OpenSolaris servers with ZFS and MySQL.
SmugMug is a digital photo sharing website, focused on professional photographers. The site is also famous for storing huge amounts of data (photos) using local filesystems and the Amazon S3 service. Just on S3 are 100 800 terabytes of data (according to this and this).
Very interesting pots because he tels in details his experieces over some diferents points of view.
This week I did another presentation outside my city. This time it was at Maracanau in the Comsolid, a open source and digital inclusion event.
My first presentation was about ZFS filesystem and how you can take benefits from it like pooling storage and self healing. I used as base for examples my last post on it, Trying to corrupt data in a ZFS mirror.
|
|
 |
|---|---|
 |
|
 |
My next talk was about OpenSolaris. We had a lot of questions and interesting about this. We burned some cds with OpenSolaris 2008.5 and also distributed others versions of OpenSolaris like Solaris 10.
And my last presentation was a quick talk about high performance computing, a short version on that I already did before.
Was a interesting event mainly because the public was composed primarily by young students with few background on TI. It was a challenge to present some new concepts like pooling storage for those who aren’t familiar with filesystems management. I tried to keep my talk as simpler as I could and focus on daily problems and showing that you can avoid them with some open source technologies.
The full album is available at http://flickr.com/photos/silveiraneto/sets/72157605632001295/.
Ilustrative image 😛
This is the first of a serie of posts I’d like to write while I’m studying more about OpenSolaris. The idea is to create simple posts showing a specific feature through practical examples that you can reproduce in your computer.
One of the most interesting feature on OpenSolaris is the 128-bit filesystem ZFS.
For those who are starting with ZFS, the main diference is the abstraction used for volumes. Unlike traditional file systems, which reside on single devices and thus require a volume manager to use more than one device, ZFS filesystems are built on top of virtual storage pools called zpools. One zpool is constructed of virtual devices (vdevs), which are themselves constructed of block devices: files, hard drive partitions, or entire drives (the recommended usage).
In this first experiment we will construct a mirrored zpool (RAID-1) and so try to corrupt its data and see what happens. In a mirrored pool the data is replicated into many disks and that eliminates the critical point, ie if one disks stops the data is not corrupted. You’ll can create a mirror with two or more disks and inside a pool you can have many mirrors. By example, one pool of 100Gb made by two mirrors, each one with 50Gb and each mirror made by volumes of 25Gb. You’ll scale your pool according your needs and capabilities.
This part of corrupt data make this experiment a little dangerous. You have these options:
- Install OpenSolaris in your disk and have at least two more disks to make a mirrored zpool. I don’t recommend this option because if you don’t know exactly what you are doing you can lose important data if you use the wrong volumes.
- Install OpenSolaris in a virtual machine and create fake volumes for this experiment. If you make some mistake nothing too bad will happen. That’s the option I’m using. Here I’m using VirtualBox with OpenSolaris 2008.5. VirtualBox is a free virtual machine, easy to use and works well with OpenSolaris.
Although there is already a graphical tool for manage ZFS, this is not available at OpenSolaris 2008.5. Also for who are studying ZFS a little bit deeper, know how to manage it by command line tools is interesting.
With your OpenSolaris booted, open a terminal and log yourself as root. Consult your available devices with echo|format.
If you are familiar with Linux, OpenSolaris nomenclature for devices may sound strange. I recommend you to take a look at this document.
To create a pool with the devices c4d1 (80G) and c5d1 (60GB) just type zpool create ourpool mirror c4d1 c5d1.
Explaining this command word by word:
Diagram of ourpool. Icons from Everaldo Coelho.
If your command works, it’ll works silently e will returns nothing. For check pool’s status do a zpool status ourpool.
This output shows that a pool called ourpool is ONLINE and is made of one only mirror, that is made of two devices c4d1 e c5d1.
We can list all pools with zpool list.
Ourpool has approximately 60Gb size which 900kb is already used for store metadata. As we did a mirror using volume of 60Gb and 80Gb, the mirror size is determined by the smaller volume. The another pool, rpool is a pool that OpenSolaris creates by defaul to place the system.
Now we’ll populate the pool with data. These data could be real important data like data base files, your photo collection or personal documents. For illustrative effect I’m using a 100Mb empty file called data. mkfile 100m data.
While the file creation I did a zpool iostat -v ourpool too see the IO traffic in the pool. Note that there’s traffic on both disks as they form a mirror.
We will create and save a file of md5 checksum of date to be able to check its integrity later, md5sum data > data.md5. Too see if a checksum matches we do a md5sum –check data.md5.
Now comes the critical part of this simulation. We will simulate a physical defect on the disc. Storage devices will fail at some point, but we don’t know when. When it happens it can corrupt your data or stop important applications.
Let’s get 20Mb of garbage from /dev/urandom e throw them in the disk c4d1, dd if=/dev/urandom of=/dev/dsk/c4d1 bs=1024 count=20480. There’s more fun (and expensive) ways to case physical defects in a disk, take a look into this video where they use ZFS and hammers. 🙂
Ready, the damage was done. Let’s look the pool status, zpool status ourpool.
We see no error but the ZFS uses strongly memory cache. Let’s force clean this cache by disabling and enabling the pool. First cd / to assure we are not into the pool, so zpool export ourpool followed by zpool import ourpool.
Checking it’s status again, zpool status ourpool.
Pool remains ONLINE but ZFS noticed that something is wrong.
Let see the data integrity, md5sum –check data.md5.
This is one of the characteristic of self healing in ZFS. The corruption that occurred in one volume was silently repaired. In a traditional volume manager you would not only lost our data but not event know that a corruption has occurred.
In this point the system administrator should be warmed to take some action on the defective disk. Here some advices:
I also did a screencast the resumes the entire process:
This post is a english translation for this post.
Imagem meramente ilustrativa 😛
Esse é o primeira de uma série de posts que eu pretendo escrever ao mesmo tempo que eu estudo mais sobre OpenSolaris. A idéia é criar artigos simples mostrando funcionalidades bem especÃficas através de experimentos práticos que você pode replicar em seu computador.
Uma das funcionalidades mais interessantes do OpenSolaris é o sistema de arquivo de 128-bits ZFS. Para quem está começando a principal diferença é a abstração utilizadas para os volumes. Ao contrário dos sistemas de arquivos tradicionais, onde cada um reside em um único dispositivo e requerem um gerente de volumes para usar mais de um dispositivo, o sistema de arquivo ZFS é construÃdo sob pools de armazenamento virtuais chamados zpools. Um zpool é construÃdo de dispositivos virtuais (vdevs) quem são constituÃdos de volumes de bloco (arquivos, partições de um disco ou discos inteiros, o que é o recomendado).
Esse primeiro experimento vai ser construir zpool espelhado (RAID-1) e depois tentar corromper os dados dele e ver o que acontece. Em um pool espelhado, os dados são replicados para vários discos e isso elimina o ponto crÃtico, ou seja, se um disco parar de funcionar, os dados não são corrompidos. Você pode criar um espelho com dois ou mais discos e dentro de um mesmo pool você pode ter vários espelhos. Por exemplo, um pool de 100Gb formado por dois espelhos, cada um com 50GB e cada espelho formado por discos rÃgidos de 25Gb cada um. Você vai dimensionar seu pool de acordo com suas necessidades e capacidades.
Essa parte de corromper os dados faz experimento ser um pouco perigoso. Eu te aconselho a fazer uma dessas sugestões:
- Instalar o OpenSolaris no seu disco e pelo menos outros dois discos rÃgidos para fazer um zpool espelhado. Eu não recomendo essa opção porque se você não souber muito bem o que está fazendo você pode corromper dados acidentalmente.
- Instalar o OpenSolaris em uma máquina virtual e criar discos rÃgidos falsos para utilizar no experimento. Assim mesmo que você cometa algum erro nada de muito ruim vai acontecer. Essa é a opção que eu escolhi e aqui eu estou usando o VirtualBox com o OpenSolaris 2008.5. É uma máquina virtual livre, muito fácil de usar e o OpenSolaris se dá muito bem com ele.
Embora já exista uma interface gráfica para controle para ZFS, está não está incluÃda no OpenSolaris 2008.5. Além disso para quem quer estudar o ZFS um pouco mais a fundo, acho que conhecer seu controle via linha de comando é interessante.
Com o OpenSolaris já bootado, abra um terminal, logue-se como root e consulte os seus dispositivos com echo|format.
Se você esta bem familiarizado com Linux você deve estranhar a nomenclatura dos dispositivos no OpenSolaris, eu recomendo voce dar uma olhada nesse documento.
Parar criar um pool com os dispositivos c4d1 (80G) e o c5d1 (60GB) basta simplesmente um zpool create ourpool mirror c4d1 c5d1.
Explicando esse comando palavra a palavra:
Diagrama do pool que criamos. Ãcones do Everaldo Coelho.
Se o comando funcionou, ele agira silenciosamente e nao retornar nada. Para checar o estatus do pool fazemos um zpool status ourpool.
Essa saÃda nos diz que o pool chamado ourpool está com o status ONLINE e que o pool é composto de um único mirror que por sua vez é composto dos dispositivos c4d1 e c5d1.
Podemos listar todos pools com zpool list.
O ourpool tem aproximadamente 60GB de tamanho dos quais 900kb já foram usados para guardar metadados. Como nós usamos um espelho de discos de 60GB e de 80GB, o tamanho do pool foi determinado pelo tamanho do menor disco. O outro pool, rpool é o pool que o OpenSolaris cria por default para abrigar o sistema inteiro.
Agora vamos povoar o pool com dados. Estes dados poderiam ser dados reais importantes como os arquivos de um banco de dados, sua coleção de fotos ou seu arquivo de documentos. Para efeitos ilustrativos eu vou usar aqui um arquivo vazio de 100Mb chamado data. mkfile 100m data.
Durante a criação do arquivo eu dei um zpool iostat -v ourpool para ver o tráfego na entrada/saÃda do pool. Note que há tráfego em ambos os discos já que eles formam um espelho.
Vamos criar e guardar um checksum md5 do arquivo data para podermos checar sua integridade mais tarde, md5sum data > data.md5. Para checarmos se esse checksum bate com o checksum do arquivo fazemos um md5sum –check data.md5.
Agora vem a parte crÃtica dessa simulação. Vamos simular um defeito fÃsico no disco. Dispositivos de armazenamento vão falhar em algum momento, só não sabemos quando, e quando acontecer ele poderá corromper seus dados ou parar aplicações importantes.
Vamos pegar 20 Mb de lixo retirado do /dev/urandom e joga-los no disco c4d1, dd if=/dev/urandom of=/dev/dsk/c4d1 bs=1024 count=20480. Existem formas mais divertidas (e caras) de provocar defeitos fÃsicos, dê uma olhada nesse vÃdeo onde eles usam ZFS e martelos. 🙂
Pronto, o estrago foi feito. Olhamos o status do pool, zpool status ourpool.
Não vemos nenhum erro até porque o ZFS é baseado em cache na memória. Vamos forçar ele a limpar esse cache derrubando e subindo o pool. Primeiro cd / para termos certeza que não estamos dentro do pool, depois um zpool export ourpool seguido de um zpool import ourpool.
Olhamos o status novamente, zpool status ourpool.
O pool continua ONLINE mas o ZFS sabe que alguma coisa está errada.
Vamos checar a integridade dos dados checando nosso checksum md5, md5sum –check data.md5.
Os dados estão intactos.
Essa é uma das caracterÃsticas de self-healing do ZFS. A corrupção de dados que ocorreu em um dos volumes espelhados foi reparada silenciosamente. Em um gerenciador de volumes tradicional você não só teria perdido seus dados como nem sequer saberia que houve corrupção.
Mas nesse ponto o administrador do sistema deve ser avisado para tomar alguma atitude em relação ao disco defeituoso. Estas são algumas sugestões:
Pra resumir tudo, eu fiz esse screencast:
Documentação complementar:
Há uma tradução para inglês desse post.
InfoBrasil is a tradicional IT business event in my city. This year we got a space for Open Source and Free Software where I did a presentation about OpenSolaris. I posted our grid yesterday.
That was my first presentation about OpenSolaris so I focused to showing that OpenSolaris 2008.5 is a GNU/OpenSolaris distribution but you can access features like ZFS, DTrace and Zones. I used those slides that Tirthankar Das, Solaris Cluster Engineering at Sun Microsystems, did for FISL 2008. Most of the audience was composed from students and they showed very impressed with ZFS. In my next OpenSolaris presentation I’ll try to focus more on ZFS demos. 😉 Someone in the audience did a random number generator code live. We used it to prize some OpenSolaris gifts like tshirts and sticks. 😀
I hope that for now on that we can use better this space and for establish a good dialog between communities, governments and enterprises.
All photos ares avaliable at my personal album for that event.
Você lembra que eu falei sobre Cursos de Java de Graça para Estudantes?
O Sun Student Courses abriu mais um curso (Introduction to Solaris and opensolaris.org), agora sobre Solaris e opensolaris.org no mesmo estilo do curso anterior (Real World Technologies: NetBeans GUI Builder, JRuby, JavaFX, and JavaME).
São 5 tópicos:
SMF – Service Management Framework
Solaris Containers, OS level virtualization for Solaris
E só para lembrar:
