PHP functional HTML rendering

Working with HTML integration while writing code is sometimes tedious and time consuming, most of the times just copy paste.

Recently viewed a post about adding some fun in doing so.

Some may found it complicated, some may found unnecessary. but someone who are keen to explore new things or hidden things here is example.

 

First start with two basic functions that will carry out most of our complicated things

 

function tag(){
$args = func_get_args();
$nm = array_shift($args);
$content = array_shift($args);
$attrs = array_chunk($args, 2);
echo “<$nm “;
foreach($attrs as $chunk)
echo $chunk[0].’=’.'”‘.$chunk[1].'” ‘;
echo ‘>’;
if(is_string($content) || is_numeric($content) || empty($content))
echo $content;
else
$content();
echo “</$nm>”;
}

function etag(){
$args = func_get_args();
$nm = array_shift($args);
$attrs = array_chunk($args, 2);
echo “<$nm “;
foreach($attrs as $chunk)
echo $chunk[0].’=’.'”‘.$chunk[1].'” ‘;
echo “/>”;
}

So the first argument to our tag function is the tag name, second is the content to render inside the tag and the rest of the arguments are the attribute name and value pairs. Same goes for the etag function which renders empty elements, but then sans the content argument of course.

Below are a few examples of usage, first a simple login form.

tag(‘div’, function(){
tag(‘form’, function(){
echo ‘Username:’;
etag(‘input’, ‘type’, ‘text’, ‘name’, ‘username’);
echo ‘Password:’;
etag(‘input’, ‘type’, ‘password’, ‘name’, ‘password’);
etag(‘input’, ‘type’, ‘submit’, ‘value’, ‘Submit’, ‘name’, ‘submit’);
}, ‘method’, ‘post’);
}, ‘class’, ‘normal-pad’);

Then a more complicated scenario where we want to render a table of statistics:

function statsTable($stats, $headers, $fields, $sums){
tag(‘table’, function() use ($stats, $sums, $headers, $fields){
tag(‘tr’, function() use ($headers){
foreach($headers as $header)
tag(‘th’, $header);
});
foreach($stats as $s){
tag(‘tr’, function() use ($s, $fields){
foreach($fields as $field)
tag(‘td’, $s[$field]);
});
}
tag(‘tr’, function() use ($sums, $fields){
foreach($fields as $field)
tag(‘td’, is_numeric($sums[$field]) ? $sums[$field] : ”);
}, ‘class’, ‘sum-row’);
}, ‘class’, ‘stats-table’);
}

 

 

How to install memcache on windows

Check your operating system whether 32bit or 64 bit. Based on that you need to download the binary version.

  1. 64bit Os – http://s3.amazonaws.com/downloads.northscale.com/memcached-win64-1.4.4-14.zip

  2. 32bit Os – http://code.jellycan.com/memcached/

  • Place the binary file on C or D location
  • Now Run the Command Prompt as Administrator – type the cmd –  C:/memcached/memcached.exe  -d install
  • Once Installed, Start the service – C:\memcached\memcached.exe -d start
  • Verify the service running properly on Start- > Run -> services.msc
  • Check your php extensions directory for php_memcache.dll
  • If you don’t have it, Download http://pecl.php.net/package/memcache/3.0.8/windows
  • Now Edit the Php.ini file and add following lines at extension section
  1. extension=php_memcache.dll
  2. Restart your apache server and Now we are good go.

If you are using Drupal then add below lines to settings.php

$conf['cache_backends'][] = 'sites/all/modules/contrib/memcache/memcache.inc';
$conf['cache_default_class'] = 'MemCacheDrupal';
$conf['cache_class_cache_form'] = 'DrupalDatabaseCache';

you can check the memcahce settings at “admin/reports/memcache”

 

If you are using Core php then use below code for checking memcache working or not.

<?php
$memcache = new Memcache;
$memcache->connect('localhost', 11211) or die ("Could not connect");
$version = $memcache->getVersion();
echo "Server's version: ".$version."<br/>\n";
$tmp_object = new stdClass;
$tmp_object->str_attr = 'test';
$tmp_object->int_attr = 123;
$memcache->set('key', $tmp_object, false, 10) or die ("Failed to save data at the server");
echo "Store data in the cache (data will expire in 10 seconds)<br/>\n";
$get_result = $memcache->get('key');
echo "Data from the cache:<br/>\n";
var_dump($get_result);
?>

Common coding pitfalls for beginners as well as for experts

Even though we are having more  experience then too at some expert level we too do some beginner level mistakes, for me this is 100% true

 

Found one post on google reader from NetTuts+ want to share it for viewers. Please note that its not mine but sharing as liked it.

 

Learn from our mistakes; don’t do these things!

 


JavaScript Tips

1 – Unnecessary DOM Manipulation

The DOM is slow. Limiting your interaction with it will greatly increase your code’s performance. Consider the following (bad) code:

// anti-pattern
for (var i = 0; i < 100; i++){
	var li = $("<li>").html("This is list item #" + (i+1));
	$("#someUL").append(li);
}

This code actually modifies the DOM 100 times, and unnecessarily creates 100 jQuery objects. 100! A more correct approach would be to either use a document fragment, or build up a string that contains the 100 <li/> elements, and then appends that HTML to the containing element. That way, you jump into the DOM a total of once. Here’s an example:

var liststring = "";
for (var i = 100; i > 0; i--){
	liststring += "<li>This is list item #" + (99- i);
}
document.getElementById("someUL").innerHTML(liststring);

As noted above, with this technique, we touch the DOM only once, which is an improvement, but it also relies on string concatenation to build a large string. There’s a different way that we could approach this, using arrays.

var liststring = "<li>"
var lis = [];
for (var i = 100; i > 0; i--){
	lis.push("This is list item #" + (99- i));
}
liststring += lis.join("</li><li>") + "</li>";
document.getElementById("someUL").innerHTML(liststring);

When building large strings, storing each piece of the string as an item within an array element and calling join() is more efficient than string concatenation. This is one of the fastest and easiest ways to build repetitive HTML in JavaScript without using a template library or framework.

2 – Inconsistent Variable & Function Names in JavaScript

This next item isn’t a performance issue, but is extremely important – especially if you are working on code that other people work on, as well. Keep your identifiers (variable and function names) consistent. Consider the following variables as an example:

var foo = "bar";
var plant = "green";
var car = "red";

It wouldn’t make sense to add another variable, called Something. This introduces inconsistency in your variable naming pattern, causing your brain to cognitively flag this variable as being different or special. This is why constants in most languages are traditionally defined with all caps.

You can take this a step further by maintaining similar length, grammatical structure, and explanatory nature when naming functions. For example, consider the following contrived function:

function subtractFive(number){
	return number - 5;
}

Naming a function that adds five to a given number should follow the same pattern, shown here:

function addFive(number){
	return number + 5;
}

Sometimes, you might name a function to indicate its return value. For instance, you might name a function that returns an HTML stringgetTweetHTML(). You might also prepend a function’s name with do, if the function simply performs an operation and doesn’t return a value, eg:doFetchTweets().

Constructor functions typically follow the tradition of classes in other languages, capitalizing the first letter:

function Dog(color){
	this.color = color;
}

As a general rule of thumb, you should be descriptive when naming your identifiers. Classify them together with other similar identifiers by maintaining a naming pattern that is readable and offers hints to the nature of a variable or function’s purpose.

3 – Use hasOwnProperty() in for...in Loops

JavaScript’s arrays are not associative; trying to use them as such is frowned upon by the community. Objects, on the other hand, can be treated as hash tables, and you can iterate over an object’s properties by using the for...inloop, like so:

for (var prop in someObject) {
    alert(someObject[prop]); // alert's value of property
}

The problem, however, is that the for...in loop iterates over every enumerable property on the object’s prototype chain. This can be problematic if you only want to use the properties that exist on the actual object.

You can solve this issue by using the hasOwnProperty() method. Here’s an example:

for (var prop in someObject) {
    if (someObject.hasOwnProperty(prop)) {
        alert(someObject[prop]); // alert's value of property
    }
}

This version only alerts the values of the properties that directly reside onsomeObject.

4 – Comparing Boolean Values

Comparing boolean values in a condition is a waste of computation time. Take a look at the following for an example:

if (foo == true) {
    // do something for true
} else {
    // do something for false
}

Notice the condition: foo == true. The comparison of foo and true is unnecessary because foo is already a boolean value (or it’s a truthy or falsey one). Instead of comparing foo, simply use it as the condition, like this:

if (foo) {
    // do something for true
} else {
    // do something for false
}

To test for false, use the logical NOT operator, as shown below:

if (!foo) {
    // do something if foo is false
} else {
    // do something if foo is true
}

5 – Event Binding

Events are a complicated subject in JavaScript. Gone are the days of inlineonclick event handlers (except in some very rare “splash page” cases). Instead, use event bubbling and delegation.

Let’s imagine that you have a grid of pictures that need to launch a modal lightbox window. Here’s what you shouldn’t do. Note: we’re using jQuery here, assuming you are using a similar library. If not, the same bubbling principles also apply to vanilla JavaScript.

The relevant HTML:

<div id="grid-container">
	<a href="someimage.jpg"><img src="someimage-thumb.jpg"></a>
	<a href="someimage.jpg"><img src="someimage-thumb.jpg"></a>
	<a href="someimage.jpg"><img src="someimage-thumb.jpg"></a>
	...
</div>

The (bad) JavaScript:

$('a').on('click', function() {
	callLightbox(this);
});

This code assumes that calling the lightbox involves passing an anchor element that references the full size image. Instead of binding to each anchor element, bind to the #grid-container element instead.

$("#grid-container").on("click", "a", function(event) {
	callLightbox(event.target);
});

In this code, both this and event.target refer to the anchor element. You can use this same technique with any parent element. Just make sure to define the element that should be the event’s target.

6 – Avoid Ternary Redundancy

The overuse of ternary statements is quite common both in JavaScript and PHP.

// javascript
return foo.toString() !== "" ? true : false;

// php
return (something()) ? true : false;

A condition expression always returns a true or false value, meaning you don’t need to explicitly add true/false as ternary values. Instead, you could simply return the condition:

// javascript
return foo.toString() !== "";

// php
return something();

PHP Tips

7 – Use Ternary When Appropriate

if...else statements are a central part of most languages. But doing something simple, such as assigning a value to a variable based upon a condition – well, they can junk up your code. Consider the following code:

if ($greeting)
{
    $post->message = 'Hello';
}
else
{
    $post->message = 'Goodbye';
}

This code can be reduced to one line, while still maintaining readability by using the ternary operator, like this:

$post->message = $greeting ? 'Hello' : 'Goodbye';

It’s clear, concise, and gives you the functionality you need.

As useful as the ternary operator is, the most important guideline is not to over-use it! The goal of coding is not to cramp your logic into as few lines as possible.

8 – Throw Exceptions Instead of Inception-Style Nesting

Let’s face it: many levels of nesting is ugly and difficult to maintain/read. The following code is a relatively simplified example, but they get much worse over time:

// anti-pattern
$error_message = null;
if ($this->form_validation->run())
{
	if ($this->upload->do_upload())
	{
		$image = $this->upload->get_info();
		if ( ! $this->image->create_thumbnail($image['file_name'], 300, 150))
		{
			$error_message = 'There was an error creating the thumbnail.';
		}
	}
	else
	{
		$error_message = 'There was an error uploading the image.';
	}
}
else
{
	$error_message = $this->form_validation->error_string();
}
// Show error messages
if ($error_message !== null)
{
	$this->load->view('form', array(
		'error' => $error_message,
	));
}
// Save the page
else
{
	$some_data['image'] = $image['file_name'];
	$this->some_model->save($some_data);
}

That’s some nasty code, but you can make it drastically cleaner by using exceptions, like so:

try
{
	if ( ! $this->form_validation->run())
	{
		throw new Exception($this->form_validation->error_string());
	}
	if ( ! $this->upload->do_upload())
	{
		throw new Exception('There was an error uploading the image.');
	}
	$image = $this->upload->get_info();
	if ( ! $this->image->create_thumbnail($image['file_name'], 300, 150))
	{
		throw new Exception('There was an error creating the thumbnail.');
	}
}
// Show error messages
catch (Exception $e)
{
	$this->load->view('form', array(
		'error' => $e->getMessage(),
	));
	// Stop method execution with return, or use exit
	return;
}
// Got this far, must not have any trouble
$some_data['image'] = $image['file_name'];
$this->some_model->save($some_data);

It might be the same number of lines, but it allows for considerably more readable and maintainable code. It also avoids those difficult debugging sessions, where you’ve missed a possible path through the if statement. Keep it simple!

9 – False-Happy Methods

Being exception-happy is far more advantageous than being false-happy.

Ruby or Python developers are used to watching for trivial exceptions. While that sound tedious, it’s actually quite a good thing. If anything goes wrong, an exception is thrown, and you instantly know where the problem is.

In PHP – and especially when using older frameworks, such as CodeIgniter – you get what I refer to as “false-happy code” (as opposed to exception-happy). Instead of having an exception get all up in your face, it just returns a falsevalue and assigns the error string to some other property. This forces you to fish it out of the class using a get_error(); method.

Being exception-happy is far more advantageous than being false-happy. If an error occurs within your code (eg: could not connect to S3 to upload an image, or a value is empty, etc.), then throw an exception. You can also throw specific types of exceptions by extending the Exception class, like so:

class CustomException extends Exception {}

Throwing a custom exception makes debugging considerably easier.

Tip 10 – Use Guard Clauses

It’s common to use if statements to control a function or method’s execution path. It’s tempting to test a condition and execute a lot of code when the condition results in true, only to simply return in the else statement. For example:

function someFunction($param) {
    if ($param == 'OK') {
       $this->doSomething();
       return true;
    } else {
       return false;
    }
}

This kind of solution, however, represents a potential for spaghetti code. You can make this code easier to read by reversing the condition. Here’s the better version:

function someFunction($param) {
    if ($param != 'OK') return false;
    $this->doSomething();
    return true;
}

Isn’t that easier to read? It’s a simple change that makes a drastic difference in the readability of your code.

Tip 11 – Use while for Simple Iterations

The for loop is commonly used when you need, for example, a counter. Here’s a simple for loop:

for (var i = 0; i < x; i++) {
    ...
}

There are some very good reasons to use a for loop, but a while loop may be better if you just need something simple, like this:

var i = x;
while (i--) {
    ...
}

It doesn’t work in every situation, but it is an alternative.

Tip 12 – Keep Methods Maintainable

This is easily one of the most frequent mistakes made by newcomers.

A method is an object’s unit of work, and limiting your methods to a maintainable size makes your code easier to read and maintain. Take a look at the following monster method:

class SomeClass {
	function monsterMethod() {
		if($weArePilots) {
			$this->goAndDressUp();
			$this->washYourTeeth();
			$this->cleanYourWeapon();
			$this->takeYourHelmet();
			if($this->helmetDoesNotFit())
				$this->takeAHat();
			else
				$this->installHelmet();
			$this->chekcYourKnife();
			if($this->myAirplain() == "F22")
				$this->goToArmyAirport();
			else
				$this->goToCivilianAirport();
			$this->aim();
			$this->prepare();
			$this->fire();
		}
	}
}

Consider breaking this monster method into smaller, descriptive chunks, each being responsible for performing one well-abstracted action. This is easily one of the most frequent mistakes made by newcomers.

class SomeClass {
	function monsterMethod() {
		if($weArePilots) {
			$this->prepareYourself();
			$this->tryHelmet();
			$this->findYourAirport();
			$this->fightEnemy();
		}
	}
	private function prepareYourself() {
		$this->goAndDressUp();
		$this->washYourTeeth();
		$this->cleanYourWeapon();
		$this->chekcYourKnife();
	}
	private function tryHelmet() {
		$this->takeYourHelmet();
		if($this->helmetDoesNotFit())
			$this->takeAHat();
		else
			$this->installHelmet();
	}
	private function findYourAirport() {
		if($this->myAirplain() == "F22")
			$this->goToArmyAirport();
		else
			$this->goToCivilianAirport();
	}
	private function fightEnemy() {
		$this->aim();
		$this->prepare();
		$this->fire();
	}
}

There we go: cleaner, and easier to debug!

Step 13 – Avoid Deep Nesting

Too many levels of nesting makes code difficult to read and maintain. Consider the following:

function doSomething() {
    if ($someCondition) {
        if ($someOtherCondition) {
            if ($yetSomeOtherCondition) {
                doSomethingSpecial();
            }
            doSomethingElse();
        }
    }
}

You can refer to Tip #10 to make this code easier to read by reversing some of the conditions.

function doSomething() {
    if (!$someCondition) {
        return false;
    }
    if (!$someOtherCondition) {
        return false;
    }
    if ($yetSomeOtherCondition) {
        doSomethingSpecial();
    }
    doSomethingElse();
}

This code is considerably cleaner and produces the same results as before.

When you find yourself with nested if statements, closely examine your code; your method may be performing more than one task. Here’s an example:

function someFunc() {
	if($oneThing) {
		$this->doSomething();
		if($anotherThing)
			$this->doSomethingElse();
	}
}

In these cases, extract the nested methods into their own method:

function someFunc() {
	if($oneThing) {
		$this->doSomething();
		$this->doAnotherThing($anotherThing);
	}
}
private doAnotherThing($anotherThing) {
	if($anotherThing)
		$this->doSomethingElse();
}

Tip 14 – Avoid Magic Numbers and Strings

Magic numbers and strings are evil. Define variables or constants with the values you want to use in your code.

Instead of this:

function someFunct() {
	$this->order->set(23);
	$this->order->addProduct('superComputer');
	$this->shoppingList->add('superComputer');
}

Specify what those numbers and strings mean, and assign them to a variable with a meaningful name, like this:

function someFunct() {
	$orderId = 23;
	$selectedProductName = 'superComputer';
	$this->order->set($orderId);
	$this->order->addProduct($selectedProductName);
	$this->shoppingList->add($selectedProductName);
}

While some might argue that we’re needlessly creating variables, the performance hit is negligible. Readability always takes priority. Remember: don’t optimize for performance until you can describe why it’s necessary.

Step 15 – Use Built-In Array Functions

Use the built-in array functions instead of foreach().

Not Ideal:

foreach (&$myArray as $key =>$element) {
   if ($element > 5) unset ($myArray[$key]);
}

Better:

$myArray = array_filter($myArray, function ($element) { return $element <= 5;});

PHP offers a variety of array methods. They’re confusing at first, but take a day and try to learn as many as possible.

Tip 16 – Don’t Overuse Variables

It’s easy to overuse variables, but remember that variables are stored in memory. For every variable you create, the system needs to allocate memory for that variable. Look at this code:

public function get_posts() {
	$query = $this->db->get('posts');
	$result = $query->result();
	return $result;
}

The $result variable isn’t necessary. The following code omits that variable:

public function get_posts() {
	$query = $this->db->get('posts');
	return $query->result();
}

The difference is subtle, but we were able to improve this simple example. We kept the $query variable because it relates to the database, while $resultrelated more to our logic.


General Programming Recommendations

Tip 17 – Rely on the Database Engine

Anything less is a code smell.

A database is designed for working with data; use its tools and abilities to make your application more efficient.

For example, you can avoid redundant database queries in many circumstances. Most plug-and-play user management scripts use two queries for user registration: one to check whether the e-mail/username already exists and another to actually add it to the database. A much better approach is to set the username field to UNIQUE. You can then use native MySQL functions to check whether or not the record was added to the database.

Tip 18: Properly Name Your Variables

The days of naming your variables xyz are over (unless, of course, you’re dealing with a coordinate system). A variable represents an important part of your logic. Don’t want to type a long name? Get a better IDE. Modern IDEs auto-complete variable names in a blink of an eye.

Always be coding for six months from now. Are you certain that you’ll remember what that $sut variables refers to a year from now? Likely not: be descriptive. Anything less is a code smell.

Tip 19 – Methods Represent Actions

Mistakes happen; the key is to learn from them.

Name your methods with verbs representing the action they perform. The main concept is the exact opposite of the variable naming scheme. Use a short, but descriptive, name in a large scope (ie: public methods), and use a longer and more detailed name in a short scope (ie: private / protected methods). This helps make your code read like well written prose.

Also avoid any language other than English, when naming your methods. It’s annoying to read function names like 做些什麼() or делатьчтото() in your project. It may be impossible for other programmers to understand your intent. While it might seem arrogant, for better or worse, English is the adopted language of code. Try to use it, if we’re working on a large team.

Tip 20: Structure Recommendations

Finally, code structure is just as important to readability and maintainability as anything else we’ve talked about today. Here are two recommendations:

  • Indent with four or two space-width tabs. Anything more, such as eight spaces, is too much and will make your code difficult to read.
  • Set a reasonable line-width and respect it. Forty characters in a line? We’re not in the ’70s any more; set your limit to 120 characters, put a mark on the screen, and force yourself or your IDE to respect that limit. 120 characters gives you a nice width without making you scroll.

Conclusion

“I’ve never made a stupid programming mistake.” — No one, ever.

Mistakes happen; the key is to learn from them. We at Nettuts+ have made, and will continue to make, mistakes. Our hope is that you learn from our mistakes so that you can avoid them in the future. But, to be honest, the best way to learn best practices is to make the mistakes yourself!

Thanks for reading!

Getting started with PHP PDO and SQLITE

In android i used to have sqlite db which is light weight and sufficiently smart for smaller operations

PHP too supports the SQLITE db operations so i searched for some time and found certain code to make use of the SQLITE in php

 

First thing i tried to create the db file, on php.net site I got following code snippet

<?php
if ($db = sqlite_open('mysqlitedb', 0666, $sqliteerror)) { 
    sqlite_query($db, 'CREATE TABLE foo (bar varchar(10))');
    sqlite_query($db, "INSERT INTO foo VALUES ('fnord')");
    $result = sqlite_query($db, 'select bar from foo');
    var_dump(sqlite_fetch_array($result)); 
} else {
    die($sqliteerror);
}
?>

After I executed the code with sample values and some data, when i checked in SQLite db browser, it gave me version issue then i came across fact that This function only support database of SQLite 2 or below. For SQLite 3, you must use PDO.

So i started searching on SQLite with PDO

Finally some sort of working code I got which can create the db file execute some statements and finally that can be browsed via the sqlite browser below is the code with comments in between.. so

Enjoy

In following code explanation given for how to create sqlite db, create some tables, insert data, drop table, access the data.. and so on

The inline commenting is good enough to understand the code, so not writing here in much detail…

 

<?php
 try {
 // Create (connect to) SQLite database in file
 $file_db = new PDO('sqlite:users.sqlite3');
 // Set errormode to exceptions
 $file_db->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
 /**************************************
 * Create tables *
 **************************************/
 // Create table users with two colums firstname and last name
 $file_db->exec("CREATE TABLE IF NOT EXISTS tbl_users (
 id INTEGER PRIMARY KEY, 
 firstname TEXT, 
 lastname TEXT 
 )");
 
 /**************************************
 * Set initial data *
 **************************************/
 // Array with some test data to insert to database 
 $users = array(
 array('firstname' => 'Abhijeet',
 'lastname' => 'K'),
 array('firstname' => 'Testing firstname',
 'lastname' => 'Testing lastname'),
 array('firstname' => 'Dinesh',
 'lastname' => 'Patil')
 );
 // Prepare INSERT statement to SQLite3 file db
 $insert = "INSERT INTO tbl_users (firstname, lastname) 
 VALUES (:firstname, :lastname)";
 $stmt = $file_db->prepare($insert);
 
 // Bind parameters to statement variables
 $stmt->bindParam(':firstname', $firstname);
 $stmt->bindParam(':lastname', $lastname);
 
 
 // Loop thru all users data and execute prepared insert statement
 foreach ($users as $u) {
 // Set values to bound variables
 $firstname = $u['firstname'];
 $lastname = $u['lastname'];
 // Execute statement
 $stmt->execute();
 }
 
 // Select all data from users tabel and display 
 $result = $file_db->query('SELECT * FROM tbl_users');
 
 foreach($result as $row) {
 echo "Firstname: " . $row['firstname'] . "&nbsp;";
 echo "Lastname: " . $row['lastname'] . "<br>";
 
 echo "<br>";
 }
 
 
 /**************************************
 * Drop tables *
 **************************************/
 
 // Drop table users from file db
 $file_db->exec("DROP TABLE tbl_users");
 // Close file db connection
 $file_db = null;
 
 }
 catch(PDOException $e) {
 // Print PDOException message
 echo $e->getMessage();
 }
?>

How to execute PHP code on existing html page?

The way to execute PHP on a .html page is to modify your .htaccess file. This file may be hidden, so depending upon your FTP program you may have to modify some settings to see it. Then you just need to add this line for .html:

AddType application/x-httpd-php .html

If you only plan on including the PHP on one page, it is better to setup this way:
<Files abc.html>
AddType application/x-httpd-php .html
</Files>
This code will only make the PHP executable on the abc.html file, and not on all of your html pages.

How to configure a basic php application on amazon ec2

The most important thing is you need your valid amazon login details

Login with the credentials and you will land on the home screen, dont get confused with various options to setup working php mysql application you need a few options.

The first most important thing is to generate a ssh key and import in the console A good guide on how to generate can be found HERE

Once imported name the key you can remember say php or mykey etc I use php.

Next you can go to Elastic Beanstalk section, select launch new environment.

Choose the required parameters the most important is container type

Select the one which suits you for your php mysql I selected 32 bit amazon linux running php 5.3

Check the parameters for most of columns dont change any but to keep the default one

After filling all the details your environment is can be seen on the same screen, wait for the color or environment to change to green which indicates ALL IS WELL…

You are now almost 50% done till this step.

Go to environment url to check the sample code working, some welcome app or sample application screen

If not then there is something wrong and you can check the environment logs or events to check status.

Next go to EC2 section and your newly created instance is waiting for you.

Its now time to access the newly created instance to upload some files.

Allocate one Elastic Ip from the EC2->Elastic IP section to your instance.

In the instance details you can now see the IP allocated. Just to confirm type that IP address in browser and you should see the same app page that was there while checking the environment url.

Next step is set up putty to access the instance.

Convert the generated key in first step to PPK (Putty Private Key) format. An illustrative guide can be found HERE.

For a Quick revision we followed steps as

  1. Generated key pair
  2. Created instance with default environment
  3.  Imported keys to ec2  environment
  4.  Edited instance to allocate the IP to allow SSH
Next step is to actually ssh your newly created instanceGo to instance section under EC2->instances and click on your instance and note down the elastic IP associated.
Now Open the Puty for SSH connection
In connection details put your elastic IP and under SSH -> Auth section browse the ppk file you created.
When prompted enter user name as ec2-user and password as what you selected while creating your key.

Bingo…….

If  ALL IS WELL you can see the favorite black screen for linux console.. Its now your play ground.. and now time to do some settings.
Check for php version and apache version for curiosity, Its not necessary but to start with or to brush your knowledge if you are accessing it after long time like me.
The default apache location is /etc/httpd/
and default webroot will be /var/www/html
Edit some files or create a new one..using VI editor and check on front end..

How to configure the amazon relational database service to use in amazon cloud applications

This is new series where in I will explain step by step configuration of the amazon cloud servers to host and run php mysql applications

 

In this session I will first explain to use ARDS (Amazon Relational Database Service) and then binding the ARDS instance to get accessible from your app.

 

The main requirement is you should have AWS account.  Login with your credentials and go ahead to create your first ARDS db

First select RDS tab from the top menu

Then select launch new instance

Select available instances like mysql,oracle,MSSQL etc

Fill in the necessary details like instance class, storage, db identifier, username, password etc

 

 

Once selected all the necessary options the DB instance is now seen on RDS dashboard.

Next Step is to authorize access to your database

Select the db security group from the left hand side options

Possible select the default security group and grant access for application or the specific IP to access the same.

After authorized access you can now access your database

Note the EndPoint url username and password

With this credentials and security settings you can now connect to your db instance.