In the beginning I opted for NFS as shared file system, then decided to go for OCFS2 which is open source, maintained by Oracle, and available under GPLv2.

Some Pros/Cons of NFS, GFS2 and OCFS2 (from Dublin OSS barcamp) :

NFS

• Pro: standard, cross-platform, easy to implement
• Con: Poor performance, single point of failure (single locking manager, even in HA)

GFS2

• Pro: Very responsive on large data files, works on physical and virtual, quota and SE-Linux support, faster than EXT3 when I/O operations are on the same node
• Con: Only supported with Red Hat, Performance issues on accessing small files on several subdirectory on different nodes

OCFS2

• Pro: Very fast with large and small data files on different node with two types of performance models (mail, data file). Works on a physical and virtual.
• Con: Supported only through contract with Oracle or SLES, no quota support, no on-line resize

First we need to install OCFS2 tools :

sudo apt-get install ocfs2-tools

There is another package ocfs2console that you want to install to configure the cluster via GUI, but since I’m using ubuntu server I’m skipping this to configure my cluster manually.

Create on every node attached to storage /etc/ocfs2/cluster.conf

sudo vi /etc/ocfs2/cluster.conf

With the content below, only replace node1 and node1 with their respective names and IP for each node :

node:
name = node1
cluster = ocfs2
number = 0
ip_address = 10.10.0.0
ip_port = 7777
node:
name = node2
cluster = ocfs2
number = 1
ip_address = 10.10.0.1
ip_port = 7777
cluster:
name = ocfs2
node_count = 2

Now you reconfigure ocfs2-tools with the default values :

sudo dpkg-reconfigure ocfs2-tools

then restart services :

sudo /etc/init.d/o2cb restart
sudo /etc/init.d/ocfs2 restart

If your fiber card connected to your host/storage, and virtual disks created and presented you should run fdisk to see it :

$ sudo fdisk -l
Disk /dev/sda: 1073.7 GB, 1073741824000 bytes
255 heads, 63 sectors/track, 130541 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x02020202

the result have been truncated to show only one virtual disk, and you might see multiple /dev/sda, /dev/sdb, /dev/sdc… according to your configuration in addition to your local hard disks. What I have done is creating a 1TB partition that I will share between my two nodes :

$ sudo fdisk /dev/sda

In fdisk menu choose “n” for new partition, and choose your partition size according to your requirements. Then use “w” to write changes and exit.

Finally we create a ocfs2 partition table :

$ mkfs.ocfs2 /dev/sda

mount your partition :

$ sudo mkdir /archives
$sudo mount -t ocfs2 /dev/sda /archives

or you can add it to fstab to mount automatically on boot :

$ /dev/sda /archives ocfs2 _netdev 0 0

The _netdev option is used here to prevent the system from attempting to mount these file systems until the network has been enabled on the system.

You want to test your new partition, and you will notice that every file/folder created on node1 is automatically available on node2, and vise-versa.

Enjoy !

Related posts:

1. Two nodes Load balance and Failover with keepalived and Ubuntu Server 10.04 x64
2. Create a Master Master MySQL replication – Ubuntu Server 10.04 x64

First you will need to set at least two IPs (10.10.0.1 and 10.10.0.2) for your servers, and one virtual (10.10.0.3) shared between the two servers, you will have for the first interface :

# The primary network interface
auto eth0
iface eth0 inet static
address 10.10.0.1
netmask 255.255.255.0
network 10.10.0.0
broadcast 10.10.0.255
gateway 10.10.0.250
auto eth0:0
iface eth0:0 inet static
address 10.10.0.3
netmask 255.255.255.0
network 10.10.0.0
broadcast 10.10.0.255

and the second interface :

# The primary network interface
auto eth0
iface eth0 inet static
address 10.10.0.2
netmask 255.255.255.0
network 10.10.0.0
broadcast 10.10.0.255
gateway 10.10.0.250
auto eth0:0
iface eth0:0 inet static
address 10.10.0.3
netmask 255.255.255.0
network 10.10.0.0
broadcast 10.10.0.255

Then we can start by installing keepalived (v1.1.17 is available in Ubuntu repositories)

sudo apt-get install keepalived

You will have to create two configuration files for the first node 10.10.0.1 (Master) and second node 10.10.0.2 (Backup). So we add in the master node :

usr01@server01:~$ sudo nano /etc/keepalived/keepalived.conf
# Keepalived Configuration File
vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 10
priority 200
virtual_ipaddress {
10.10.0.3/24
}
notify_master "/etc/keepalived/notify.sh del 10.10.0.3"
notify_backup "/etc/keepalived/notify.sh add 10.10.0.3"
notify_fault "/etc/keepalived/notify.sh add 10.10.0.3"
}
virtual_server 10.10.0.3 80 {
delay_loop 30
lb_algo rr
lb_kind DR
persistence_timeout 50
protocol TCP
real_server 10.10.0.1 80 {
weight 100
HTTP_GET {
url {
path /index.php
digest d41d8cd98f00b204e9800998ecf8427e
}
connect_timeout 3
nb_get_retry 3
delay_before_retry 2
}
}
real_server 10.10.0.2 80 {
weight 100
HTTP_GET {
url {
path /index.php
digest d41d8cd98f00b204e9800998ecf8427e
}
connect_timeout 3
nb_get_retry 3
delay_before_retry 2
}
}
}


And in the backup node :

usr01@server02:~$ cat /etc/keepalived/keepalived.conf
# Keepalived Configuration File
vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 10
priority 100
virtual_ipaddress {
10.10.0.3/24
}
notify_master "/etc/keepalived/notify.sh del 10.10.0.3"
notify_backup "/etc/keepalived/notify.sh add 10.10.0.3"
notify_fault "/etc/keepalived/notify.sh add 10.10.0.3"
}
virtual_server 10.10.0.3 80 {
delay_loop 30
lb_algo rr
lb_kind DR
persistence_timeout 50
protocol TCP
real_server 10.10.0.1 80 {
weight 100
HTTP_GET {
url {
path /check.txt
digest d41d8cd98f00b204e9800998ecf8427e
}
connect_timeout 3
nb_get_retry 3
delay_before_retry 2
}
}
real_server 10.10.0.2 80 {
weight 100
HTTP_GET {
url {
path /check.txt
digest d41d8cd98f00b204e9800998ecf8427e
}
connect_timeout 3
nb_get_retry 3
delay_before_retry 2
}
}
}

The hash is created using, notice that you can add exception so apache don’t log check.txt requests.

usr01@server01:~$ genhash -s 10.10.0.1 -p 80 -u /check.txt
MD5SUM = d41d8cd98f00b204e9800998ecf8427e
usr01@server01:~$ genhash -s 10.10.0.2 -p 80 -u /check.txt
MD5SUM = d41d8cd98f00b204e9800998ecf8427e

Also in both nodes we have to add a small utility to notify :


#!/bin/bash
VIP="$2"
case "$1" in
add)
/sbin/iptables -A PREROUTING -t nat -d $VIP -p tcp -j REDIRECT
;;
del)
/sbin/iptables -D PREROUTING -t nat -d $VIP -p tcp -j REDIRECT
;;
*)
echo "Usage: $0 {add|del} ipaddress"
exit 1
esac
exit 0

Launch keepalived on the two nodes :

sudo /etc/init.d/keepalived start

Now we need to enable ip_forward on the two nodes permanently

net.ipv4.ip_forward = 1

restart network on the two nodes

sudo /etc/init.d/networking restart

And we can check that load balancing is working correctly on Master :

usr01@server02:~$ sudo ipvsadm -L -n
[sudo] password for usr01:
IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
-> RemoteAddress:Port Forward Weight ActiveConn InActConn
TCP 10.10.0.3:80 rr persistent 50
-> 10.10.0.1:80 Local 100 0 0
-> 10.10.0.2:80 Route 100 0 0

Also on Backup server

usr01@server02:~$ sudo ipvsadm -L -n
[sudo] password for usr01:
IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
-> RemoteAddress:Port Forward Weight ActiveConn InActConn
TCP 10.10.0.3:80 rr persistent 50
-> 10.10.0.1:80 Route 100 0 0
-> 10.10.0.2:80 Local 100 0 0

We are almost done, we only need to add a preroute rule on the backup node manually to get started :

usr01@server02$ iptables -A PREROUTING -t nat -d 10.10.0.3 -p tcp -j REDIRECT
usr01@server02$ iptables -t nat --list
Chain PREROUTING (policy ACCEPT)
target prot opt source destination
REDIRECT tcp -- anywhere 10.10.0.3
Chain POSTROUTING (policy ACCEPT)
target prot opt source destination
Chain OUTPUT (policy ACCEPT)
target prot opt source destination

That’s all.

Now you can connect to http://10.10.0.3 and you can notice load distributed between two nodes internally. In case one of the nodes fail, it will takes few seconds until the backup server notice the failure and update its iptables prerouting rule. When apache service goes down, you will notice that request on port 80 will be automatically redirected to second node.

As I have mentioned in the beginning, failover control cannot goes without downtime in such architecture, but it still great to distribute load if you are limited in hardware.

Finally, it will be much easier (even faster) to load balance using Round Robin DNS from active directory for example, if you can manage to monitor failed service or node, however this architecture remain better on failover even with a short downtime.

Related posts:

1. Shared OCFS2 partition on Ubuntu Server 10.04 x64
2. Create a Master Master MySQL replication – Ubuntu Server 10.04 x64

The key feature in DMS, ECM, or e-Archiving solutions is the “Document” itself. It’s all about creating documents and retrieving them, everything else is built on this feature : security, workflow, search and index, backup, restore, encryption … etc.

The NoSQL movement have the answer for most ECM implementations since it’s mainly about key/value data store, where you can mainly store documents (of data) and retrieve them.

In a NoSQL environment there is no lock, so your ECM is highly available, scalable, and replicated across your system. What else are we looking for ? Oh yes consistency !

The “eventually consistent” is probably the only negative point for adopting NoSQL against the “enforced consistency” of RDBMS. In the same time you cannot easily distribute RDBMS and scale it horizontally, which is more fun to do in NoSQL.

DMS of the future will need to adopt NoSQL  :

• because new systems are built for Internet : highly available documents is required feature, imagine a place where everybody can really write simultaneously – no locks-in.
• If you request a specific document, you will get it and there is no difference here with RDBMS, noSQL is even more performing.
• The “eventually consistent” will not really change anything, when you need a global view of the data (stats for example) you will get it “consistent”.
• Backup of documents could be done easily – and you will fall in love with replication
• Sharding is your friend for large distributed database of documents

I won’t need to mention successful case studies, because most cases are trying to replace RDBMS for relational databases, while DMS is mainly about documents. Using NoSQL database coupled with an RDBMS could also be a great alternative to provide additional features for documents management.

Lots of great NoSQL implementation already available such as CouchDB, MongoDB, BerkleyDB, Neo4j, Memcachedb, Tokyo Cabinet, BigTable, Redis, … etc. and not a single DMS or e-Archiving initiative to adopt NoSQL ?

IBM Filenet, OpenText, LaserFiche, and all other companies working in the ECM, DMS, e-Archiving business should be worried, the future will be Not Only for them.

Update : as Alex mentioned on myNoSQL Magazine, and to avoid confusion, I don’t support NoSQL for content management in general, however ECM is mentioned here as it usually support document management, assets management, … etc.

Related posts:

1. Say YES to Open Source
2. YEFI e-Government Interoperability Framework

Without entering into further details, how this could happen, and why … It’s true that something wrong happened and they assumed the consequences. I’m not talking about the small amount of money they paid to get back the password, but about the scam behind it and the name of the university in question.

I wanted to profit – as usual – and focus again on the strategic decisions of considering Open source as alternative in critical mission projects. Whatever if you are talking about ERP, CRM, BPM, DMS, … the open source alternative is always available and costless compared to proprietary solutions. Best of all, open source is a guarantee to have full control on the business and get lock-free solution.

Imagine if this project was made in an open source ecosystem, the university will never get locks anywhere, and their system might be updated easily and quickly – even if something wrong happened.

Most important things to consider to avoid locks :

• Adopt Open Source technologies
• Document everything : Business, communications, code and databases
• Adopt a backup/restore strategy
• Adopt a disaster recovery strategy
• Share the knowledge in a development team, and avoid using only one developer in a large project to minimize cost. Two or more developers will get work done faster and safer.
• Separate critical mission projects, from new alpha/beta projects. Use SOA as much as possible for integration.
• Do not go e-Business if you are not ready for it and always provide alternative in case of failure. And consider seriously that the project will fail.
• finally -in Saudi Arabia specifically- ask for support, Yesser program is doing great work and their consultants might really help to secure your e-Business.

You still don’t trust open source ?

Related posts:

1. Open Source, Closed Source, We are not enemies
2. Open Source Evangelism
3. Why ECM & e-Archiving Solutions Should Adopt NoSQL

Note: Before beginning I want to mention that master/master configuration is great to avoid single point of failure in your system architecture, however it will not distribute load across the nodes. I use Mysql specifically for users management and permissions and then distribute load via my web application.

Ubuntu Server install ext4 by default, which you will need to change first to ext3, according to Lucid/Lynx release notes, if you have performance-sensitive applications – the case with a Mysql database server.

We will consider two nodes node1 and node2 with respectively 10.10.0.1 and 10.10.0.2

First install MySQL 5.1 in the two nodes :

hatem@node1$ sudo apt-get install mysql-server mysql-client

You will have to set the MySQL root password during installation.

Then we have to configure the first master node1

hatem@node1$ sudo vi /etc/mysql/my.cnf

comment out the line bind-address, then set a unique value to server-id, and the masterdbname you want to replicate.

[mysqld]
# bind-address = 127.0.0.1
server-id = 1
log_bin = /var/log/mysql/mysql-bin.log
expire_logs_days = 10
max_binlog_size = 100M
binlog_do_db = masterdbname
binlog_ignore_db = mysql
binlog_ignore_db = test

Restart database to affect changes :

hatem@node1$ sudo /etc/init.d/mysql restart

If you have a database dump you can import it in node1, however you can just create the database masterdbname manually :

hatem@node1$ mysql -u root -p
mysql> CREATE DATABASE masterdbname;

We will have to grant a username and password replication permission on the node1 :

mysql> GRANT REPLICATION SLAVE ON *.* TO 'user'@'%' IDENTIFIED BY 'password';
mysql> FLUSH PRIVILEGES;
mysql> show master status;
+------------------+----------+--------------+------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000034 | 443 | masterdbname | mysql,test |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)
mysql> quit

Now we can move to node2 and configure the mysql server :

hatem@node2$ sudo vi /etc/mysql/my.cnf

We will have the similar config here too, but with a different server-id

[mysqld]
# bind-address = 127.0.0.1
server-id = 2
log_bin = /var/log/mysql/mysql-bin.log
expire_logs_days = 10
max_binlog_size = 100M
binlog_do_db = masterdbname
binlog_ignore_db = mysql
binlog_ignore_db = test

Restart mysql

hatem@node2$ sudo /etc/init.d/mysql restart

Finally we can connect to node2 server and setup the first replication :

hatem@node2$ mysql -u root -p
mysql> CREATE DATABASE masterdbname;
mysql> CHANGE MASTER TO MASTER_HOST='10.10.0.1', MASTER_USER='user', MASTER_PASSWORD='password', MASTER_LOG_FILE='mysql-bin.000034', MASTER_LOG_POS=443;

Notice that MASTER_LOG_FILE and MASTER_LOG_POS values are from previous show master status result.

The first replication is done we can start the slave :

mysql> START SLAVE;
mysql> show slave status \G
*************************** 1. row ***************************
Slave_IO_State: Waiting for master to send event
Master_Host: 10.10.0.1
Master_User: user
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000034
Read_Master_Log_Pos: 261
Relay_Log_File: Node2-relay-bin.000002
Relay_Log_Pos: 406
Relay_Master_Log_File: mysql-bin.000034
Slave_IO_Running: Yes
Slave_SQL_Running: Yes

If the Slave_IO_Running and Slave_SQL_Running are Yes it mean your first replication is done and you can create a simple table :

At Node1 (actual master) create a table :

mysql> use masterdbname;
mysql> create table testmaster21 (mid int(11) auto_increment, PRIMARY KEY (mid)) Engine=MyISAM;

Check available tables at node2 (actual slave) … Tada :

mysql> show tables;
+------------------------+
| Tables_in_masterdbname |
+------------------------+
| testmaster21 |
+------------------------+
1 rows in set (0.00 sec)

Now the second part is very easy, we need first to check master details in node2 :

mysql> show master status;
+------------------+----------+--------------+------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000034 | 261 | masterdbname | mysql,test |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)

Then add in node1 :

mysql> CHANGE MASTER TO MASTER_HOST='10.10.0.2', MASTER_USER='user', MASTER_PASSWORD='password', MASTER_LOG_FILE='mysql-bin.000034', MASTER_LOG_POS=261;
mysql> START SLAVE;
mysql> show slave status \G
*************************** 1. row ***************************
Slave_IO_State: Waiting for master to send event
Master_Host: 10.10.0.2
Master_User: user
Master_User: user
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000034
Read_Master_Log_Pos: 261
Relay_Log_File: Node1-relay-bin.000002
Relay_Log_Pos: 406
Relay_Master_Log_File: mysql-bin.000034
Slave_IO_Running: Yes
Slave_SQL_Running: Yes

To test it you can drop table from Node2 and make sure the table is dropped on node1 too.

That’s all !

Related posts:

1. Shared OCFS2 partition on Ubuntu Server 10.04 x64
2. Two nodes Load balance and Failover with keepalived and Ubuntu Server 10.04 x64

I’m not going to defend open source, because there are enough arguments, technologies, and solutions that are very competitive and no closed technology can compete with them, however my only take is only for education.

Why most education systems “impose” the use of proprietary solutions ? I did not said that MS Office is bad, but do not force me to use this product. Why teaching kids how to use Windows, Word, Excel, PowerPoint… then Access for advanced users !

As a student I’ll have probably to write text, reports, table sheets, presentations … I don’t think this deserve to be taught separately and marked in the final exams ! People behind education programs are sometimes old fashion and love to stick to old stuff they learned, or just prefer the solution of facility if it’s about teaching few basic features documented and sponsored by the software provider.

The only good things is probably teaching Java as main programming language in most universities and colleges, and my apologies for those who are stick to Pascal “forever”. It’s okay to teach .NET but don’t stick to Visual Studio and Windows environment, there is Mono for people who don’t know it which provide an open source alternative.

In business, the choice of open or closed technology is not a matter of evangelism. I had the chance probably to work on a large open source solution using a closed source database for a government institution, and actually another new project which is based mainly on closed technology and integrated with the open source solution.

The core business solution is stable for one year already, and is mainly powered by open source technologies (operating systems, web server, web application), even the closed source database is running on an open source OS.

Getting the new project running with closed technology doesn’t much matter for me – even if I won’t recommend it if I was asked before. Making the business evolute is my only concern, and integration was really made easy between the two technologies.

My only worries today is about the capabilities of the closed technology to support a high number of users, and high traffic during peak times. In the same time I’m not much worried, because the core business is in the safe side, if the new implementation for a reason or another fail, only the “closed source” part of the system will fail and not the entire system.

Businesses and consultancies have the choice, most of the time, but they are mostly interested to work behind a giant company name to make sure that their solution will be accepted. By experience selling a custom made solution (powered by open source technologies) is much more profitable than reselling licenses of any available software, but the lack of experience and confidence doesn’t give much choices.

I think I have answered a key question here : small companies cannot compete with open source software, get behind a large company name and you will be able to sell any open source solution at a very competitive price compared to closed source one. Open and closed source are not enemies, it’s up to you to use one or the other, or make them both coexist.

Related posts:

1. Say YES to Open Source
2. Open Source Evangelism
3. e-Government as Platform

A website could be slow for many reasons, and to be able to fix it and make it run faster you have to first find problem. What you will need to know is :

1- Understand the business :

Before looking into PHP or MySQL, have a first look at the website(s) and answer these two questions :

- What is slow
- Why is it slow

Look at the page size, images, video, flash, … your issue might be in the client side and everything else might be good.
Use a tool like Firefox web developer extension and disable everything : CSS, Javascript, Images… and load the page as html to feel the difference.
The business here is NOT the business logic behind the website, it’s the interface that people use to interact with the website. If everything looks okay, you can go for further server-side investigations.

2- Understand the production environment : Operating system, PHP and MySQL versions, PHP extensions running, PHP and MySQL configurations.

Do not start optimizing code or database unless you know the exact problem, otherwise you have to start by understanding and optimizing the working environment. Some tweaks in PHP and MySQL settings might fix your problem and you won’t probably need to dig deeply into any code.

3- Understand the code :

If the websites you are looking to optimize are using a common framework or CMS, let’s say Drupal, WordPress, Zend Framework, Symfony… such websites you can deal with separetely since most optimization issues should be known and you will easily find your way to speed things up.

Otherwise, for custom code and custom application development, start with debugging and focus firstly on the database. That’s where most slow issues come from, especially if the concerned website was running fast in the beginning then become slow over the time due to database size going bigger, query & index issues…

4- Debug : detect and locate bottlenecks

Debuggers are your friends here, whatever the environment you are running. Answer again previous questions (What and Why) but this time with relation to the code itself.

You might consider running a stress test here to simulate real working environment. Such tests could help you understand more networking issues and make it easier to locate slowliness based on real scenarios. Test should also simulate real environment, and you will need to save speed result for comparison later.

5- Solution proposal and action plan

Now you can go ahead and set possible solutions : fixing bugs, caching code/queries, tweak your settings… Make sure your modifications will not affect other working website in the same environment – if any is somehow related or linked.

Finally you can run previous stress test with new configuration and updates to see the difference in speed gained. A report of previously mentioned steps should be written including result.

Related posts:

1. Create a Master Master MySQL replication – Ubuntu Server 10.04 x64

From yesser website, YEFI is defined as “a unified framework to implement e-government. It includes cross – governmental specifications and policies, to enable cross – governmental integration and facilitate G2G transactions and data sharing.”

While reading deeply about YEFI, I noticed that the framework cover almost everything we need – for integration purpose at least – between different government institutions. The common part of the schemas between different ministries is almost the same : Address, ID number, place & date of birth, Last and first name, while they keep different names.

The creation of data catalog is the first step to get these data defined, where every entry should include as fields : Name, Business information, Format, Validation, Verification, XML Schema IDs, Values, Default value, Owner, Version and Acceptance date. The data schema will be in this case the collection of all these elements defined in data catalog.

The schema should include meta data; if we are sending person’s data for example the schema should start with meta data as : Business object created, Business object updated, owner, data schema ID, Global unique object ID; then followed by person data as : Person birth place & date, First & Last name … etc.

A central repository for the standardized schemas is required to handle persistent data of oudated schemas. As every institution data might evolve over the years, and data schema will be updated; a repository should be available to document schemas versions and conversion rules.

The recommended integration technologies standards are : WebServices for middleware, UTF-16 for character sets, XML/XSL and XML schema, and finally RDF as resource description framework.

More details on YEFI program and technical documentation are available at http://www.yesser.gov.sa/english/YEFI.asp

Related posts:

1. Say YES to Open Source

The first session was about Sun SPARC enterprise servers, and I liked the idea of supporting mix of processors versions in the M4000, M500 and M9000 (the M series servers) – and it’s only Sun that offer this compared to IBM and HP. Some benchmarks also in this session and was very informative; also covered different aspect of the M-Series and CMT servers for single-threaded and multi-threaded.

In the second session the Datacenter Architect talked about Datacenter efficiency through virtualization. Andy talked about different level of virtualization Servers, Storage, and Network, in addition to virtualization tool Sun VDI software and Sun Ops Center. The business case in the end was very interesting showing 14% ROI in the first year only. There is something I noticed that virtualization tools are available free with Open Solaris, and coming soon to Solaris; and you don’t have to pay more to use them ! It’s something like when you buy a new car, then you try to use the Radio and they tell you have to pay more for this feature. Well, I totally agree with Andy and find it really ridiculous to do this; especially that I have a similar problem with HP Storage and the way they limit licencing to a fixed number of TB – so to add more capacity we’ll need a new license.

In the last session, Thomas talked about Sun Storage 7000 Unified Storage Systems. Almost all speakers was insisting on the ZFS – the famous Sun File Systems; obviously it was mentioned more frequently with the storage session. I liked especially the Enterprise SSDs, which eliminates storage bottlenecks. The ZFS pool guarantee a better performance for writes via the ZIL pool and reads via L2ARC pool – both connected to SSDs in addition to a third pool with cheap HDs.

The last session was about Sun FlashFire; also by Thomas. There was a case study of the KAUST presented by Mohammed Abdel Aal; Manager KAUST IT Computing Infrastructure. Mr Mohammed talked more about KAUST research strategy, but there is something that I liked most in KAUST IT requirements “No legacy systems, no legacy thinking”.

Overall it was great meeting IT professionals. I have already worked with Sun servers and Solaris, but I don’t have previously good knowledge of their hardware architecture. I was only familiar with ZFS and Open Solaris.

I didn’t stay for the lunch, but I expect it to be great too.

No related posts.

Building e-Government services is not that hard, not that easy also. There are many steps that should be followed to be able – at a certain time – to move totally from an old paper-based system, to a fully electronic system.

The most interesting in e-Government that you are building services for people, and people are the customers, the users, while they usually never interact during the building process – but we have many considerations to keep in mind while building for people.

Some interesting steps in e-Gov creation where we should focus mainly include :

• Business Process Re-engineering
• e-Government system architecture
• Systems interoperability and scalability
• Security : systems, network, and end-users
• Cost consideration : hardware, software, network, development in-house, outsourcing, and management
• Web-enabling requirements : accessibility, usability, technologies standards
• Supporting Multiple Communication channels
• Internal software and hardware for administration (legacy systems) : RH, Finance, DMS, Archiving, CRM, Workflow, Communication (Email, Voice, IM)

It is interesting to turn Governments process into e-Services, but building platforms that support different business process levels G2G, G2B and G2C is much more interesting.

Some experts started talking about Government 2.0, or Government as Platform. A great concept especially since it allows anybody to build government services or integrate it with other already established business process elsewhere.

The problem is that building platforms is totally different from building services, and IT developers/architects used to create web applications that do not scale at the Government level. One of these problems is the execution of the CAP theorem in Governments web applications. The fact that we require “strong consistency” in e-Government is a major limitation for high availability in web platforms.

“eventual consistency is an  eventual solution, but implement it correctly is a major obstacle. The reason why developers/architects have to better understand the best practices for building eventually consistent systems, in highly available environments.

Related posts:

1. Open Source, Closed Source, We are not enemies
2. YEFI e-Government Interoperability Framework
3. Open Source Evangelism