toolmantim

OpsWorks

AWS OpsWorks, formerly Scalarium, is a chef-based system that deeply integrates with EC2 (security policies, key pairs, etc). OpsWorks acts as web console to configure your entire system, and as a command hub for running chef-solo on all the instances.

Stacks

A stack represents a collection of inter-connected and inter-configured services.

A stack has lifecycle events which are triggered by any change to the stack configuration (such as, adding a new instance to a layer, or changing the hosts of an application). In this way, the stack acts as an event hub, notifying every instance of any changes.

kigster

max_connections = 1500                  # (change requires restart)
shared_buffers = 12000MB                # min 128kB, based on 80GB RAM DB 
temp_buffers = 8MB                      # min 800kB
work_mem = 64MB                         # min 64kB
maintenance_work_mem = 1500MB           # min 1MB

wal_level = hot_standby                 # minimal, archive, or hot_standby
checkpoint_segments = 256               # in logfile segments, min 1, 16MB each
checkpoint_completion_target = 0.9      # checkpoint target duration, 0.0 - 1.0
max_wal_senders = 6                     # max number of walsender processes

dergachev

OS X Screencast to animated GIF

This gist shows how to create a GIF screencast using only free OS X tools: QuickTime, ffmpeg, and gifsicle.

Instructions

To capture the video (filesize: 19MB), using the free "QuickTime Player" application:

mikeyk

#! /usr/bin/env python
from boto.ses.connection import SESConnection
import os
import sys
import subprocess
import socket

TMPFILE = '/var/run/postgresql/last-wal-archive-error-file.tmp'

if __name__ == '__main__':

blowmage

class TasksController < ApplicationController
  def update
    if @task.update_attributes(params[:task])
      tracker = PostSaveTaskTracker.new(@task)
      TaskPusher.new(tracker, socket_id).push_changes
      TaskMailSender.new(tracker, current_user).deliver_email
      # success response
    else
      # failure respond
    end

blowmage

class TasksController < ApplicationController
  def update
    if @task.update_attributes(params[:task])
      TaskPusher.new(@task, socket_id).push_changes
      TaskMailSender.new(@task, current_user).deliver_email
      # success response
    else
      # failure respond
    end
  end

ryanb

class TasksController < ApplicationController
  def update
    tracker = TaskTracker.new(@task)
    if @task.update_attributes(params[:task])
      TaskPusher.new(tracker, socket_id).push_changes
      TaskMailSender.new(tracker, current_user).deliver_email
      # success response
    else
      # failure respond
    end

nateware

1. Create the appropriate VPC that your application is going to live in. Create subnets for each availability zone you want to use.

2. Create VPC security group(s) for your auto-scaling instances. For example, if you're going to auto-scale web servers, create a "web" VPC security group.

3. Go into AWS console and create an ELB. Easy wizard. Select HTTP and (if needed) HTTPS. Make sure it's associated with the VPC you created in step 1.

4. Create an auto-scaling launch configuration from the CLI. The launch configuration has the AMI, size, and security group from step #2. The security group must be by ID not name ("sg-12345"):

      as-create-launch-config web --image-id ami-2e31bf1e --instance-type m1.medium \
   

-g sg-7619041a --key root

mattsoldo

-- Index hit rate
WITH idx_hit_rate as (
SELECT 
  relname as table_name, 
  n_live_tup,
  round(100.0 * idx_scan / (seq_scan + idx_scan),2) as idx_hit_rate
FROM pg_stat_user_tables
ORDER BY n_live_tup DESC
),

mlangenberg

namespace :log do
  desc "Downloads application logs to ./log/deploy/<RAILS_ENV>/<TIMESTAMP>/"
  task :fetch, :roles => :app do
      source = "#{shared_path}/log/#{rails_env}.log*"
      files_per_host = {}
      run "ls #{source}" do |channel, stream, data|
        files_per_host[channel[:host]] = data.split("\n")
      end

      destination = File.join('log', 'deploy')