We're gonna be setting up a DDNS service with automatic updates from our RaspberryPi!

No-IP service at noip.com, provides up to 3 hostnames for free. The only caveat is that they need to be confirmed every 30 days, for a small fee all those limitations are lifted.

Register a new account (or use your existing one) and setup a new hostname under the hostnames section. Once this is done come back here and we're gonna setup automatic updates!

SHH into you RaspberryPi and let's get started. (You can do a new installation following the guide here.)

Prerequisite

I like to use VIM to edit files, which doesn't come by default with
Raspbian Stretch Lite.
Type the following to install it:
$ sudo apt-get install vim

Feel free to use whatever editor you know and it's comfortable to you.

Install Dynamic Update Client

We're gonna be downloading the DUC from no-ip website.
$ cd /usr/local/src
$ sudo wget https://www.noip.com/client/linux/noip-duc-linux.tar.gz
$ sudo tar xzf noip-duc-linux.tar.gz

At this point you need to ls to check what version is the one you downloaded. At the time of writing the latest version is noip-2.1.9-1.

We need to build the sources now:
$ cd noip-2.1.9-1
$ sudo make
$ sudo make install

At this point you will be prompted by the installer for a few things:
Please enter the login/email string for no-ip.com
Please enter the password for user 'email@example.com'

This section only apply if you have multiple hosts for the same account.
2 hosts are registered to this account.
Do you wish to have them all updated?[N] (y/N)
Do you wish to have host [xxx.ddns.net] updated?[N] (y/N)

Please enter an update interval:[30]
This is the interval which you want the service to update your IP address. I find 5 minutes to be frequent enough.

Do you wish to run something at successful update?[N] (y/N)
Unless you have specific needs, you don't need to run anything after the update so you can just say no to this one.

Run DUC as a service

We need to create a service to run the DUC in background.
Create the following file:
$ sudo vim /etc/systemd/system/noip2.service

Paste the following into the newly created file:

# Simple No-ip.com Dynamic DNS Updater
#
# By Nathan Giesbrecht (http://nathangiesbrecht.com)
#
# 1) Install binary as described in no-ip.com's source file (assuming results in /usr/local/bin)
# 2) Run sudo /usr/local/bin/noip2 -C to generate configuration file
# 3) Copy this file noip2.service to /etc/systemd/system/
# 4) Execute `sudo systemctl enable noip2`
# 5) Execute `sudo systemctl start noip2`
#
# systemd supports lots of fancy features, look here (and linked docs) for a full list:
#   http://www.freedesktop.org/software/systemd/man/systemd.exec.html

[Unit]
Description=No-ip.com dynamic IP address updater
After=network.target
After=syslog.target

[Install]
WantedBy=multi-user.target
Alias=noip.service

[Service]
# Start main service
ExecStart=/usr/local/bin/noip2
Restart=always
Type=forking

You can find Nathan's gist here.
(Thank you!!)

Save the file.

Enable the service (This will guarantee that it will restart after reboots.):
$ sudo systemctl enable noip2

Start the service:
$ sudo systemctl start noip2

Verify the DDNS gets updated

To verify that the DUC is updating the DDNS correctly you can go in the no-ip.com dashboard and verify that the "Last Update" field in Dynamic DNS -> Hostnames changed.

Additionally you can see the status of the service by typing:
$ sudo service noip2 status
This will output the last few lines of logs. You should be able to see something like this:

Jun 02 14:12:28 pi systemd[1]: Starting No-ip.com dynamic IP address updater...
Jun 02 14:12:28 pi noip2[833]: v2.1.9 daemon started with NAT enabled
Jun 02 14:12:28 pi systemd[1]: Started No-ip.com dynamic IP address updater.
Jun 02 14:12:28 pi noip2[833]: example.ddns.net was already set to xxx.xxx.xxx.xxx.

Please note that the update only occurs if the IP changes. If you setup your IP when you created the new hostname it will not update until your IP differs.
Usually I set it to a different IP manually and restart the DUC to validate everything is working fine!

To restart the service type:
$ sudo service noip2 stop
$ sudo service noip2 start

Now, when we look at the status again, you can see that the IP has been updated.

Jun 02 14:29:11 pi systemd[1]: Starting No-ip.com dynamic IP address updater...
Jun 02 14:29:11 pi noip2[1173]: v2.1.9 daemon started with NAT enabled
Jun 02 14:29:11 pi systemd[1]: Started No-ip.com dynamic IP address updater.
Jun 02 14:29:11 pi noip2[1173]: example.ddns.net set to xxx.xxx.xxx.xxx

Enjoy!

Hope I saved you some time and headache.
Let me know in the comments if you encounter any issue or have any questions!

No keyboard, mouse, display or adapters required!
Works with Raspberry Pi 4, 3 (2 Model B and 1 Model B+), Zero and Zero W.

I'll walk you through the basic setup to get WiFi and SSH up and running as well as securing your Pi installation.

Grocery List

• Raspberry Pi
• 8Gb+ MicroSD Card
• Card Reader
• Internet

Let's get started.

Flashing Raspbian Stretch

Start by downloading the latest os from Raspbian Lite. Select RASPBIAN STRETCH LITE.
To flash the image we will use Etcher. It's free, well done, and available for all operating systems.

Open Etcher, click "Select image" and select the raspbian .zip you just downloaded. The name will be similar to 2017-11-29-raspbian-stretch-lite.zip.

If the SD Card is connected you your computer, it will be selected automatically.
Click "Flash!", and give it a few minutes and then you're done!

Mount the SD Card

Eject the SD Card from your reader and put it back in.
At this point, you should be able to see a mounted drive called boot.

Configure WiFi (Optional, only for Pi 3 and Zero W)

If you don't want to use WiFi, skip this step. See below on how to disable WiFi and Bluetooth.

Now all we have to do to supply WiFi configuration to the Raspberry is to create a file wpa_supplicant.conf in the root of the boot drive.
I like to use Atom for this, but any editor will do.

Copy and paste the following:

country=US
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
ssid="replace_with_your_ssid"
psk="replace_with_your_password"
key_mgmt=WPA-PSK
}

Save!

Enable SSH

To enable SSH, create an empty file ssh on the root of the boot drive. (Without dots or extensions.)

That's it!

Eject the SD card and boot up your raspberry pi! You can now SSH using the hostname (raspberrypi.local on mac, raspberrypi on windows).
$ ssh pi@raspberrypi.local
The default password is raspberry.
However, if you're using this as anything more than a development device, follow the additional steps below to secure the installation.

Disable WiFi / Bluetooth (If you're not using them.)

Open config.txt on the boot drive.
At the end of the file add the following:

dtoverlay=pi3-disable-wifi,pi3-disable-bt

You can find more options here: https://github.com/raspberrypi/firmware/blob/master/boot/overlays/README

Optimize GPU Memory-Split (If you're not using a display.)

If you don't use the HDMI or graphical features, you may want to optimize the amount of available memory.
Open config.txt on the boot drive.
At the end of the file add the following:

gpu_mem=16

16Mb is the minimum that we can force the GPU to use. This will free up at least ~50Mb of available memory.

FIX: -bash: warning: setlocale: LC_ALL: cannot change locale

If you see this error after you ssh in, you can install all the locales and it will go away. This will take a few minutes.

-bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)
-bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)
-bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)

Type $ sudo raspi-config and follow the instructions in the screenshots below. (Choices are highlighted in orange.)




Press okay and let it run until it is done.
UPDATE: If you want, you can install only en_US.UTF-8, that's the one that is needed.

Change timezone

Type $ sudo raspi-config and follow the instructions in the screenshots below. (Choices are highlighted in orange, the last step if to select your timezone.)


Press okay and we're done!

Expand partition to use all available space

When we burn an image into an SD Card, not all the disk space available in the SD Card will be recognized immediately.
To fix this we need to expand the partition.

Type $ sudo raspi-config and follow the instructions in the screenshots below. (Choices are highlighted in orange.)

Verify the disk pace with df -h. Under /dev/root you can see the free space and disk size.

Extending Memory

We only have limited memory available and little virtual memory available. Luckily Raspian has dphys-swapfile script to deal with this easily.
To edit I like to use vim $ sudo apt install vim -y, but you can use anything you like.
Type $ sudo vim /etc/dphys-swapfile to edit the file and modify the value to expand the amount of virtual memory to 2Gb. (Or more, based on your needs.)
CONF_SWAPSIZE=2048

Save, exit and reboot.
Now that we have virtual memory, let's double check it.
Type $ free and you should see the following.

You can see the last line, with our 2Gb of swap file!

Change Default Hostname

Type $ sudo raspi-config and follow the instructions in the screenshots below. (Choices are highlighted in orange.)

Change Default Password

Type $ sudo raspi-config and follow the instructions in the screenshots below. (Choices are highlighted in orange.)

Disallow password logins over SSH

Given enough time (or a weak password) a brute-force attacker could gain access to your Pi. We can make this much harder by disallowing SSH to accept password logins.

To do so, first, generate an ssh-key on your computer.
Run $ ssh-keygen, answer all questions. This will create a private/public key-pair in the directory you specify. On a Mac, I like to keep all of them in /users/my-user/.ssh/your-key-name.

Once the new key is created, we can use ssh-copy-id utility to copy it over to the Pi.
Type $ ssh-copy-id -i ~/.ssh/your-key-name pi@pihostname.

Now let's disable password logins over SSH. Add PasswordAuthentication no to your SSHD config file:
echo "PasswordAuthentication no" | sudo tee -a /etc/ssh/sshd_config.

To speed things up on a MAC, you can edit your ~/.ssh/config and add the following:

Host my-pi-name
HostName pihostname.local
User pi
IdentityFile ~/.ssh/your-key-name
ServerAliveInterval 60

Save. Now, to ssh in, all you have to do is $ ssh my-pi-name!
Reboot your system and check that you can still access the Pi!

Configure a Static IP Address (Optional)

It's a good idea to setup a static IP address so you always know where to find your Pi.

Add the following to /etc/dhcpcd.conf:

interface eth0  
static ip_address=192.168.2.200/24  
static routers=192.168.2.1  
static domain_name_servers=192.168.2.1 8.8.8.8

ip_address is the static IP address you want for your Pi.
routers is the IP of the router.
domain_name_servers is the chain that you want for your DNS. The first one is the IP address of your router and the second one is the fallback Google DNS.

Screen (Optional)

Sometimes, you want to be able to run a long ssh command, be able to close the terminal, and check if the command is done at a later time. To achieve this, we will install screen.

Type $ sudo apt-get install screen.

Once this is done, you can start a screen session with $ screen bash, this will give you a long lived session.
Terminate Session: CTRL + D.
Detach Session: CTRL + A release and then press D.
List All Sessions: $ screen -list.
Reconnect Session: $ screen -r 1245.pts-0.raspberrypi.

System Update

Let's make sure you're running the latest and the greatest!

$ sudo apt-get update
$ sudo apt-get upgrade

Done!

This should give you a good starting point to build something amazing! If you have any suggestions, write me or leave a comment below and I will add it in.

I've recently grown tired of using Amazon Linux AMI for my servers as you can never quite replicate the same development environment.

So.. here we are!
LEMP stack for the Ubuntu 16.04 LTS with PHP 7. Woot!

If you need to start up a new instance, take a look at my previous post. The only difference there would be to select Ubuntu OS instead of Amazon Linux AMI.
I'm assuming you're already ssh-ed into your instance, so.. Let's go!

Welcome Screen
As a welcome screen you see this unsettling message:

WARNING! Your environment specifies an invalid locale.
 The unknown environment variables are:
   LC_CTYPE=en_CA.UTF-8 LC_ALL=
 This can affect your user experience significantly, including the
 ability to manage packages. You may install the locales by running:

   sudo apt-get install language-pack-en
     or
   sudo locale-gen en_CA.UTF-8

To see all available language packs, run:
   apt-cache search "^language-pack-[a-z][a-z]$"
To disable this message for all users, run:
   sudo touch /var/lib/cloud/instance/locale-check.skip

Don't panic! Just type $ sudo apt-get install language-pack-en to install the missing locale files.

First, let's make sure you have all the latest goodness.
$ sudo apt-get update
$ sudo apt-get upgrade

This process will take a minute or two. If you want to see what's gonna be upgraded, you can run $ sudo apt-get list --upgradable at any time to get a list.

SWAP FILE
We only have 1 GB of memory available and no virtual memory to extend it. That alone is a major cause of server crashes and hangups. Simply creating a swap file is a well-known, effective micro instance tweak.
Create and activate a 2 GB swap file with the following:
$ sudo dd if=/dev/zero of=/swapfile bs=1M count=2048
$ sudo mkswap /swapfile
$ sudo chmod 0600 /swapfile
$ sudo swapon /swapfile
We generate the file with dd, make a swap filesystem with mkswap, set proper permissions with chmod, and mount it with swapon.

Our system is using the swap file for this session. To mount the volume at boot, we need to modify a system file. You can do this by typing:
$ sudo sh -c 'echo "/swapfile none swap sw 0 0" >> /etc/fstab'

Now that we have virtual memory, let's give it a double check.
Type $ free and you should see the following.

You can see the last line, with our 2Gb of swap file!

NGINX and PHP
sudo atp install build-essential libssl-dev
sudo apt install nginx php-cli php-fpm php-mysqlnd php-mcrypt php-mbstring php-curl php-xdebug phpunit

Let's enable the module we just installed.
sudo phpenmod mcrypt
sudo phpenmod mbstring
sudo phpenmod curl

Before we can test Nginx, we need to configure our firewall to allow access to the service. You can check the configuration of the firewall at anytime typing $ sudo ufw app list. Pretty awesome!

Open up only the ports that you will need.
$ sudo ufw allow 'Nginx HTTP' — Port 80.
$ sudo ufw allow 'Nginx HTTPS' — Port 443.

Because we're running Nginx in a micro instance we need to look out for resources usage. Let's put in a few parameters to optimize it.
$ sudo vim /etc/php/7.0/fpm/php-fpm.conf

Paste these few lines at the end of the file:

[global]
emergency_restart_threshold = 10
emergency_restart_interval = 1m
process_control_timeout = 10s

[www]
pm.max_children = 20
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 20
pm.max_requests = 200

php_admin_value[memory_limit] = 64M

We need to make a slight configuration change to make our setup more secure. In the main php-fpm configuration file, the standard setting for cgi.fix_pathinfo is set to 1. This is extremely insecure because it tells PHP to attempt to execute the closest file it can find if the requested PHP file cannot be found. This would allow users to craft PHP requests in a way that would allow them to execute scripts that they shouldn't be allowed to execute.

To rectify that, type:
$ sudo sed -i "s/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/" /etc/php/7.0/fpm/php.ini.

Another best practice I suggest to remove servers tokens. This will prevent Nginx from outputting information about your current installation, version numbers, etc.
To achieve this:
$ sudo vim /etc/nginx/nginx.conf
Uncomment server_tokens off; and save.

Nginx by default is setup to work with the group www-data. We need to set the proper permission schema so that our www-data user will have write permissions without owning the files.
Do do this we can type:
$ sudo usermod -a -G www-data ubuntu
$ exit - this will terminate your ssh session. Ssh in again and type,
$ groups to verify that the new www-data group has been added to your the ubuntu user.

It's time to set our default permissions on the /var/www folder where we will put our projects.
Set write permissions to /var/www for www-data group.
$ sudo chown -R www-data:www-data /var/www

We need to change the web root directory permissions so that the www group has write permissions:
$ sudo chmod 2775 /var/www
We also need to set the same permissions for any future subdirectories:
$ find /var/www -type d -exec sudo chmod 2775 {} +
Then we do the same for files within those directories and subdirectories:
$ find /var/www -type f -exec sudo chmod 0664 {} +

Now we're good to configure our website and the location where your project will be. Feel free to customize this part with your own domain and project name.
$ sudo mkdir /etc/nginx/sites-enabled
$ sudo vim /etc/nginx/sites-enabled/example.com

server {
    listen 80;
    server_name example.com;

    root /var/www/example/public;
    index index.html index.htm index.php;

    charset utf-8;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    access_log /var/log/nginx/example.com_access.log;
    error_log /var/log/nginx/example.com_error.log;

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/run/php/php7.0-fpm.sock;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }

    location ~ /\.ht {
        deny all;
    }
}

server {
    listen 80;
    server_name www.example.com;

    return 301 http://example.com$request_uri;
}

Before we start our services, we need to create our project folder.
$ sudo mkdir -p /var/www/example

To test things out, let's put a piece of php in it.
$ cd /var/www/example
$ sudo mkdir public
$ cd public
$ sudo vim index.php

Copy and paste the following.

<?php
  echo 'Hello Human!';

Save the file and exit.

Let's restart Nginx to apply the changes we just made.
$ sudo systemctl restart nginx

If you want to run a quick test, you can type in http://your-public-ip-address in your browser and you should see:

Take a moment, to congratulate yourself!

MYSQL
Install MySql server with:
$ sudo apt-get install mysql-server

To secure your database installation type:
$ sudo mysql_secure_installation
Set a root password and accept the remaining steps.
Consider your need for remote access. If you need it, say no when asked: "Disallow root login remotely?".

Enjoy your new server!

After a few years of using EC2 boxes for development and production, this has become my routine setup for micro and small instances.
If you need to start up a new instance, take a look at my previous post.
I'm assuming you're already ssh-ed into your instance, so.. Let's go!

Let's make sure you have all the latest goodness.
Running the update with --changelog will allow you to keep track of what's changing.
$ sudo yum install yum-plugin-changelog
$ sudo yum update --changelog

SWAP FILE
We only have 1 GB of memory available and no virtual memory to extend it. That alone is a major cause of server crashes and hangups. Simply creating a swap file is a well-known, effective micro instance tweak.
Create and activate a 2 GB swap file with the following:
$ sudo dd if=/dev/zero of=/swapfile bs=1M count=2048
$ sudo mkswap /swapfile
$ sudo chmod 0600 /swapfile
$ sudo swapon /swapfile
We generate the file with dd, make a swap filesystem with mkswap, set proper permissions with chmod, and mount it with swapon.

Add the following line to /etc/fstab to make it persist over reboot:
$ sudo vim /etc/fstab

/swapfile swap swap defaults 0 0

Feel free to use any other editor than VIM.
However VIM is very simple. Press i to be able to insert/paste text. esc to exit a mode, :x to save and quit.

Now that we have virtual memory, let's double check it.
Type $ free and you should see the following.

You can see the last line, with our 2Gb of swap file!

NGINX and PHP
$ sudo amazon-linux-extras enable php7.3 nginx1.12

$ sudo yum install nginx php-cli php-pdo php-fpm php-json php-odbc php-soap php-mbstring php-bcmath php-ldap php-gd php-mcrypt php-mysqlnd

PHP-FPM configuration. (FastCGI Process Manager)
Add the following to the end of /etc/php-fpm.d/www.conf:
$ sudo vim /etc/php-fpm.d/www.conf

Look for this line (towards the beginning) listen.acl_users = apache,nginx and put a semicolon in front of it, like the following: ;listen.acl_users = apache,nginx.
Now scroll to the end of the file and copy and paste this configuration:

[global]
emergency_restart_threshold = 10
emergency_restart_interval = 1m
process_control_timeout = 10s

[www]
listen = /var/run/php-fpm/php-fpm.sock
listen.owner = nginx
listen.group = www
listen.mode = 0664
user = nginx
group = www

pm.max_children = 20
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 20
pm.max_requests = 200

php_admin_value[memory_limit] = 256M

Nginx is setup to work with the group www. We need to create the group and set the proper permission schema.
Type in $ groups and verify that www doesn't already exist.

We can easily add it with the following commands.
$ sudo groupadd www
$ sudo usermod -a -G www ec2-user
$ exit - this will terminate your ssh session. Ssh in again and type,
$ groups to verify that the new www group has been added.

Let's create our www directory.
$ sudo mkdir /var/www
Set write permissions to /var/www for www group.
$ sudo chown -R root:www /var/www

We need to change the web root directory permissions so that the www group has write permissions:
$ sudo chmod 2775 /var/www

We also need to set the same permissions for any future subdirectories:
$ find /var/www -type d -exec sudo chmod 2775 {} +

Then we do the same for files within those directories and subdirectories:
$ find /var/www -type f -exec sudo chmod 0664 {} +

Now we're good to configure your website and the location where your project will be. Feel free to customize this part with your own domain and project name.
$ sudo mkdir /etc/nginx/sites-enabled
$ sudo vim /etc/nginx/sites-enabled/example.com.conf

server {
    listen 80;
    server_name example.com;

    root /var/www/example/public;
    index index.html index.htm index.php;

    charset utf-8;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    access_log /var/log/nginx/example.com_access.log;
    error_log /var/log/nginx/example.com_error.log;

    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/var/run/php-fpm/php-fpm.sock;
        fastcgi_index index.php;
        include fastcgi.conf;
    }

    location ~ /\.ht {
        deny all;
    }
}

server {
    listen 80;
    server_name www.example.com;

    return 301 http://example.com$request_uri;
}

To allow us to manage multiple domain or subdomain on the same server, we need to tell Nginx to load all the files under sites-enabled folder.
To do so, type:
$ sudo vim /etc/nginx/nginx.conf
After include /etc/nginx/conf.d/*.conf; add:
include /etc/nginx/sites-enabled/*.conf;
and save.

Before we start our services, we need to create our project folder.
$ sudo mkdir -p /var/www/example

To test things out, let's put a piece of php in it.
$ cd /var/www/example
$ sudo mkdir public
$ cd public
$ sudo vim index.php

Copy and paste the following.

<?php
  echo 'Hello Human!';

Comment out the section as shown, we're gonna disable the default "Welcome to NGINX" screen.

#    server {
#        listen       80 default_server;
#        listen       [::]:80 default_server;
#        server_name  _;
#        root         /usr/share/nginx/html;

        # Load configuration files for the default server block.
#        include /etc/nginx/default.d/*.conf;

#        location / {
#        }

#        error_page 404 /404.html;
#            location = /40x.html {
#        }

#        error_page 500 502 503 504 /50x.html;
#            location = /50x.html {
#        }
#    }

Save the file and exit.

Now let's start the engines!
$ sudo chkconfig nginx on — Set autostart.
$ sudo chkconfig php-fpm on — Set autostart.
$ sudo service nginx start
$ sudo service php-fpm start

If you want to run a quick test, you can type in http://your-public-ip-address in your browser and you should see:

Take a moment, to congratulate yourself!

MYSQL
Install MySql server with:
$ sudo yum install mariadb-server

Like before, start it up with:
$ sudo chkconfig mysqld on — Set autostart.
$ sudo service mysqld start

To secure your database installation type:
$ sudo mysql_secure_installation
Set a root password and accept the remaining steps.
Consider your need for remote access. If you need it, say no when asked: "Disallow root login remotely?".

Enjoy your new server!

So, you want to get started with Amazon Elastic Compute Cloud (Amazon EC2)?
Let's get to it.

Sign in or if you don't have a AWS account you can create one here.

Click on "Launch Instance".

Select Amazon Linux 2 AMI (HVM) instance type. This is a good choice as it is designed by Amazon specifically for use on EC2.

Select t2.micro "Free Tire" instance, click on "Review and Launch".

Scroll down and click on "Edit security groups"

Make sure you add HTTP rule to the group like is shown on the screenshot. Source 0.0.0/0 means you are accepting connections from any IP address.

Scroll down and review the storage type. I recommend SSD with at least 10Gb. I'll go for 20Gb. HDD space is really cheap. (General Purpose SSD is about $0.10 per GB-month of provisioned storage.)

Make sure to review all the settings and hit "Launch".

You'll be prompted to create a new key to connect to the server through SSH. Select "Create a new key pair" and insert the name of the key. Use any name you like. Hit "Download Key Pair" and your key will be downloaded. Make sure to back it up. If you lose it, you won't be able to connect to your server. You've been warned!
Now click on "Launch Instances".

You're server is spinning up, take a moment to congratulate yourself!

Now you need to assign an elastic IP to your instance. This ensures that if something happen to the instance, you can easily swap servers and retain the IP. Elastic IPs are re-assignable.
Click on "Allocate New Address".

Select the elastic IP, click on "Actions" and "Associate Address".

Select your instance name and click "Associate". This will be your IP address from now on. Also the previous public IP address will be released.

That's it. If you go on the Dashboard you'll see your instance getting ready.

Let's configure your computer to connect to the new server when it's ready.

On a Windows you can click here and follow the guide ;)
On a Mac you can follow those steps. Make sure you have Sublime Text installed.

Copy the key file to your desktop, then rename key.pem.txt to key.pem.
Open up the terminal and run:
$ cd desktop
$ cp key.pem ~/.ssh
$ chmod 400 ~/.ssh/key.pem

The last command makes sure your private key is protected by assigning the right permissions to it.

Now, with Sublime Text, open ~/.ssh/config. If you don't see hidden files you can use the shortcut ⌘ + ⇧ + . to show them in the open window.

Add this configuration and save.

Host name-server
HostName 000.000.000.000
User ec2-user
IdentityFile ~/.ssh/key.pem
ServerAliveInterval 60

Now you can open the terminal and type $ ssh name-server. The first time you will be asked to accept a new fingerprint from a new machine, type yes.
Congratulations! You're now logged to your server!!

A little explanation of the configuration:
Host is the name the you want to use to ssh into your server.
HostName is the IP address.
User is always ec2-user by default.
IdentityFile is the path to your private key.
ServerAliveInterval keeps the connection alive while you're not using it. Even though this is not necessary, when you're connected to your servers it allows you to keep the connection open indefinitely. Without it, the connection will timeout.

UPDATE: Rdio API has now been shut down.
Thank you all for stopping by and we hope we've given a helping hand for your music's smooth sailing.

If you're reading this, you've probably heard the news. Rdio has been acquired by Pandora. It will shut down in a few weeks.
As an Rdio user and totally in love with this beautifully crafted streaming service, I felt obligated to do something about it. Also, I always wanted to play with the Rdio API but never had the right motive.

I started building an Rdio exporter after I first heard the news because I wanted to be able to export all my data while waiting to see what Rdio would come up with. Also I wanted to make sure that it was gonna be formatted not only readable by a machine, but also by me. You know.. just in case I decided to reimport all my music manually to Spotify!
It took a while to get it ready for prime time.

A big thanks you goes to Danielle that came up with design and user flow!

So.... here it is! — rdio.ivancarosati.com

This tool allow you to sign in with your Rdio account and export your entire collection, playlists and anything you've ever favourited. You can chooce to export in .csv or .xlsx. If you're looking to keep a reference for you of your music, .xlsx is gonna be better. Once your data is ready, I'll email you a .zip file with everything in it.
Click here for an example! Yes, that's my Rdio account..

You can see how it works below.

I would love for you to use it and let me know what you think. If you have any question shoot me a tweet or comment below.

So, your Arduino DUE just came in the mail.
You're all excited, you unpack it and connect it to your USB, Open the Arduino IDE and you go to Tools → Board.
Nothing!
The Arduino DUE is missing from the list.

Here's how you install the software for the Arduino DUE.

Tools → Board → Boards Manager...
Type Arduino SAM in the search box.

Click on the Arduino SAM Boards (32-bits ARM Cortex-M3) and hit install. It may take a while, you'll need to download ~50Mb.

Once it's done, you'll see that package as installed. Good!

Now go back to Tools → Board and you'll see Arduino DUE listed at the bottom. Select it and you're done!

Let's make a LED blink! (no extra hardware necessary)

Make sure you've connected the Arduino DUE to the port labeled PROGRAMMING port at the bottom of the board.
Select the correct Port in Tools → Port as shown below.

Arduino DUE comes with an on-board LED that you can control on the digital pin 13. Let's use it!
Copy and paste the following code into the IDE.

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(200);              // wait for 0.2 second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(200);              // wait for 0.2 second
}

Hit the upload button and let it upload.

Awesome!