Upload images into an s3 bucket using PHP

Amazon S3 (Simple Storage Service) is a cloud-based storage service provided by Amazon Web Services (AWS) that allows users to store and retrieve data anywhere on the web. In PHP, you can interact with S3 buckets using the AWS SDK for PHP.

Here's an example of how to upload a file to an S3 bucket using PHP:

Copy the code from here.

<?php 

class S3 {
    // ACL flags
    const ACL_PRIVATE = 'private';
    const ACL_PUBLIC_READ = 'public-read';
    const ACL_PUBLIC_READ_WRITE = 'public-read-write';

    private static $__accessKey; // AWS Access key
    private static $__secretKey; // AWS Secret key


    /**
    * Constructor, used if you're not calling the class statically
    *
    * @param string $accessKey Access key
    * @param string $secretKey Secret key
    * @return void
    */
    public function __construct($accessKey = null, $secretKey = null) {
        if ($accessKey !== null && $secretKey !== null)
            self::setAuth($accessKey, $secretKey);
    }


    /**
    * Set access information
    *
    * @param string $accessKey Access key
    * @param string $secretKey Secret key
    * @return void
    */
    public static function setAuth($accessKey, $secretKey) {
        self::$__accessKey = $accessKey;
        self::$__secretKey = $secretKey;
    }


    /**
    * Get a list of buckets
    *
    * @param boolean $detailed Returns detailed bucket list when true
    * @return array | false
    */
    public static function listBuckets($detailed = false) {
        $rest = new S3Request('GET', '', '');
        $rest = $rest->getResponse();
        if ($rest->error === false && $rest->code !== 200)
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::listBuckets(): [%s] %s", $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }
        $results = array(); //var_dump($rest->body);
        if (!isset($rest->body->Buckets)) return $results;

        if ($detailed) {
            if (isset($rest->body->Owner, $rest->body->Owner->ID, $rest->body->Owner->DisplayName))
            $results['owner'] = array(
                'id' => (string)$rest->body->Owner->ID, 'name' => (string)$rest->body->Owner->ID
            );
            $results['buckets'] = array();
            foreach ($rest->body->Buckets->Bucket as $b)
                $results['buckets'][] = array(
                    'name' => (string)$b->Name, 'time' => strtotime((string)$b->CreationDate)
                );
        } else
            foreach ($rest->body->Buckets->Bucket as $b) $results[] = (string)$b->Name;

        return $results;
    }


    /*
    * Get contents for a bucket
    *
    * If maxKeys is null this method will loop through truncated result sets
    *
    * @param string $bucket Bucket name
    * @param string $prefix Prefix
    * @param string $marker Marker (last file listed)
    * @param string $maxKeys Max keys (maximum number of keys to return)
    * @return array | false
    */
    public static function getBucket($bucket, $prefix = null, $marker = null, $maxKeys = null) {
        $rest = new S3Request('GET', $bucket, '');
        if ($prefix !== null && $prefix !== '') $rest->setParameter('prefix', $prefix);
        if ($marker !== null && $prefix !== '') $rest->setParameter('marker', $marker);
        if ($maxKeys !== null && $prefix !== '') $rest->setParameter('max-keys', $maxKeys);
        $response = $rest->getResponse();
        if ($response->error === false && $response->code !== 200)
            $response->error = array('code' => $response->code, 'message' => 'Unexpected HTTP status');
        if ($response->error !== false) {
            trigger_error(sprintf("S3::getBucket(): [%s] %s", $response->error['code'], $response->error['message']), E_USER_WARNING);
            return false;
        }

        $results = array();

        $lastMarker = null;
        if (isset($response->body, $response->body->Contents))
            foreach ($response->body->Contents as $c) {
                $results[(string)$c->Key] = array(
                    'name' => (string)$c->Key,
                    'time' => strToTime((string)$c->LastModified),
                    'size' => (int)$c->Size,
                    'hash' => substr((string)$c->ETag, 1, -1)
                );
                $lastMarker = (string)$c->Key;
                //$response->body->IsTruncated = 'true'; break;
            }


        if (isset($response->body->IsTruncated) &&
        (string)$response->body->IsTruncated == 'false') return $results;

        // Loop through truncated results if maxKeys isn't specified
        if ($maxKeys == null && $lastMarker !== null && (string)$response->body->IsTruncated == 'true')
        do {
            $rest = new S3Request('GET', $bucket, '');
            if ($prefix !== null) $rest->setParameter('prefix', $prefix);
            $rest->setParameter('marker', $lastMarker);

            if (($response = $rest->getResponse(true)) == false || $response->code !== 200) break;
            if (isset($response->body, $response->body->Contents))
                foreach ($response->body->Contents as $c) {
                    $results[(string)$c->Key] = array(
                        'name' => (string)$c->Key,
                        'time' => strToTime((string)$c->LastModified),
                        'size' => (int)$c->Size,
                        'hash' => substr((string)$c->ETag, 1, -1)
                    );
                    $lastMarker = (string)$c->Key;
                }
        } while ($response !== false && (string)$response->body->IsTruncated == 'true');

        return $results;
    }


    /**
    * Put a bucket
    *
    * @param string $bucket Bucket name
    * @param constant $acl ACL flag
    * @return boolean
    */
    public function putBucket($bucket, $acl = self::ACL_PRIVATE) {
        $rest = new S3Request('PUT', $bucket, '');
        $rest->setAmzHeader('x-amz-acl', $acl);
        $rest = $rest->getResponse();
        if ($rest->error === false && $rest->code !== 200)
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::putBucket({$bucket}): [%s] %s",
            $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }
        return true;
    }


    /**
    * Delete an empty bucket
    *
    * @param string $bucket Bucket name
    * @return boolean
    */
    public function deleteBucket($bucket = '') {
        $rest = new S3Request('DELETE', $bucket);
        $rest = $rest->getResponse();
        if ($rest->error === false && $rest->code !== 204)
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::deleteBucket({$bucket}): [%s] %s",
            $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }
        return true;
    }


    /**
    * Create input info array for putObject()
    *
    * @param string $file Input file
    * @param mixed $md5sum Use MD5 hash (supply a string if you want to use your own)
    * @return array | false
    */
    public static function inputFile($file, $md5sum = true) {
        if (!file_exists($file) || !is_file($file) || !is_readable($file)) {
            trigger_error('S3::inputFile(): Unable to open input file: '.$file, E_USER_WARNING);
            return false;
        }
        return array('file' => $file, 'size' => filesize($file),
        'md5sum' => $md5sum !== false ? (is_string($md5sum) ? $md5sum :
        base64_encode(md5_file($file, true))) : '');
    }


    /**
    * Use a resource for input
    *
    * @param string $file Input file
    * @param integer $bufferSize Input byte size
    * @param string $md5sum MD5 hash to send (optional)
    * @return array | false
    */
    public static function inputResource(&$resource, $bufferSize, $md5sum = '') {
        if (!is_resource($resource) || $bufferSize <= 0) {
            trigger_error('S3::inputResource(): Invalid resource or buffer size', E_USER_WARNING);
            return false;
        }
        $input = array('size' => $bufferSize, 'md5sum' => $md5sum);
        $input['fp'] =& $resource;
        return $input;
    }


    /**
    * Put an object
    *
    * @param mixed $input Input data
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @param constant $acl ACL constant
    * @param array $metaHeaders Array of x-amz-meta-* headers
    * @param string $contentType Content type
    * @return boolean
    */
    public static function putObject($input, $bucket, $uri, $acl = self::ACL_PRIVATE, $metaHeaders = array(), $contentType = null) {
        if ($input == false) return false;
        $rest = new S3Request('PUT', $bucket, $uri);

        if (is_string($input)) $input = array(
            'data' => $input, 'size' => strlen($input),
            'md5sum' => base64_encode(md5($input, true))
        );

        // Data
        if (isset($input['fp']))
            $rest->fp =& $input['fp'];
        elseif (isset($input['file']))
            $rest->fp = @fopen($input['file'], 'rb');
        elseif (isset($input['data']))
            $rest->data = $input['data'];

        // Content-Length (required)
        if (isset($input['size']) && $input['size'] > 0)
            $rest->size = $input['size'];
        else {
            if (isset($input['file']))
                $rest->size = filesize($input['file']);
            elseif (isset($input['data']))
                $rest->size = strlen($input['data']);
        }

        // Content-Type
        if ($contentType !== null)
            $input['type'] = $contentType;
        elseif (!isset($input['type']) && isset($input['file']))
            $input['type'] = self::__getMimeType($input['file']);
        else
            $input['type'] = 'application/octet-stream';

        // We need to post with the content-length and content-type, MD5 is optional
        if ($rest->size > 0 && ($rest->fp !== false || $rest->data !== false)) {
            $rest->setHeader('Content-Type', $input['type']);
            if (isset($input['md5sum'])) $rest->setHeader('Content-MD5', $input['md5sum']);

            $rest->setAmzHeader('x-amz-acl', $acl);
            foreach ($metaHeaders as $h => $v) $rest->setAmzHeader('x-amz-meta-'.$h, $v);
            $rest->getResponse();
        } else
            $rest->response->error = array('code' => 0, 'message' => 'Missing input parameters');

        if ($rest->response->error === false && $rest->response->code !== 200)
            $rest->response->error = array('code' => $rest->response->code, 'message' => 'Unexpected HTTP status');
        if ($rest->response->error !== false) {
            trigger_error(sprintf("S3::putObject(): [%s] %s", $rest->response->error['code'], $rest->response->error['message']), E_USER_WARNING);
            return false;
        }
        return true;
    }


    /**
    * Puts an object from a file (legacy function)
    *
    * @param string $file Input file path
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @param constant $acl ACL constant
    * @param array $metaHeaders Array of x-amz-meta-* headers
    * @param string $contentType Content type
    * @return boolean
    */
    public static function putObjectFile($file, $bucket, $uri, $acl = self::ACL_PRIVATE, $metaHeaders = array(), $contentType = null) {
        return self::putObject(S3::inputFile($file), $bucket, $uri, $acl, $metaHeaders, $contentType);
    }


    /**
    * Put an object from a string (legacy function)
    *
    * @param string $string Input data
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @param constant $acl ACL constant
    * @param array $metaHeaders Array of x-amz-meta-* headers
    * @param string $contentType Content type
    * @return boolean
    */
    public function putObjectString($string, $bucket, $uri, $acl = self::ACL_PRIVATE, $metaHeaders = array(), $contentType = 'text/plain') {
        return self::putObject($string, $bucket, $uri, $acl, $metaHeaders, $contentType);
    }


    /**
    * Get an object
    *
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @param mixed &$saveTo Filename or resource to write to
    * @return mixed
    */
    public static function getObject($bucket = '', $uri = '', $saveTo = false) {
        $rest = new S3Request('GET', $bucket, $uri);
        if ($saveTo !== false) {
            if (is_resource($saveTo))
                $rest->fp =& $saveTo;
            else
                if (($rest->fp = @fopen($saveTo, 'wb')) == false)
                $rest->response->error = array('code' => 0, 'message' => 'Unable to open save file for writing: '.$saveTo);
        }
        if ($rest->response->error === false) $rest->getResponse();

        if ($rest->response->error === false && $rest->response->code !== 200)
            $rest->response->error = array('code' => $rest->response->code, 'message' => 'Unexpected HTTP status');
        if ($rest->response->error !== false) {
            trigger_error(sprintf("S3::getObject({$bucket}, {$uri}): [%s] %s",
            $rest->response->error['code'], $rest->response->error['message']), E_USER_WARNING);
            return false;
        }
        $rest->file = realpath($saveTo);
        return $rest->response;
    }


    /**
    * Get object information
    *
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @param boolean $returnInfo Return response information
    * @return mixed | false
    */
    public static function getObjectInfo($bucket = '', $uri = '', $returnInfo = true) {
        $rest = new S3Request('HEAD', $bucket, $uri);
        $rest = $rest->getResponse();
        if ($rest->error === false && ($rest->code !== 200 && $rest->code !== 404))
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::getObjectInfo({$bucket}, {$uri}): [%s] %s",
            $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }
        return $rest->code == 200 ? $returnInfo ? $rest->headers : true : false;
    }


    /**
    * Set logging for a bucket
    *
    * @param string $bucket Bucket name
    * @param string $targetBucket Target bucket (where logs are stored)
    * @param string $targetPrefix Log prefix (e,g; domain.com-)
    * @return boolean
    */
    public static function setBucketLogging($bucket, $targetBucket, $targetPrefix) {
        $dom = new DOMDocument;
        $bucketLoggingStatus = $dom->createElement('BucketLoggingStatus');
        $bucketLoggingStatus->setAttribute('xmlns', 'http://s3.amazonaws.com/doc/2006-03-01/');

        $loggingEnabled = $dom->createElement('LoggingEnabled');

        $loggingEnabled->appendChild($dom->createElement('TargetBucket', $targetBucket));
        $loggingEnabled->appendChild($dom->createElement('TargetPrefix', $targetPrefix));

        // TODO: Add TargetGrants

        $bucketLoggingStatus->appendChild($loggingEnabled);
        $dom->appendChild($bucketLoggingStatus);

        $rest = new S3Request('PUT', $bucket, '');
        $rest->setParameter('logging', null);
        $rest->data = $dom->saveXML();
        $rest->size = strlen($rest->data);
        $rest->setHeader('Content-Type', 'application/xml');
        $rest = $rest->getResponse();
        if ($rest->error === false && $rest->code !== 200)
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::setBucketLogging({$bucket}, {$uri}): [%s] %s",
            $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }
        return true;
    }


    /**
    * Get logging status for a bucket
    *
    * This will return false if logging is not enabled.
    * Note: To enable logging, you also need to grant write access to the log group
    *
    * @param string $bucket Bucket name
    * @return array | false
    */
    public static function getBucketLogging($bucket = '') {
        $rest = new S3Request('GET', $bucket, '');
        $rest->setParameter('logging', null);
        $rest = $rest->getResponse();
        if ($rest->error === false && $rest->code !== 200)
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::getBucketLogging({$bucket}): [%s] %s",
            $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }
        if (!isset($rest->body->LoggingEnabled)) return false; // No logging
        return array(
            'targetBucket' => (string)$rest->body->LoggingEnabled->TargetBucket,
            'targetPrefix' => (string)$rest->body->LoggingEnabled->TargetPrefix,
        );
    }


    /**
    * Set object or bucket Access Control Policy
    *
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @param array $acp Access Control Policy Data (same as the data returned from getAccessControlPolicy)
    * @return boolean
    */
    public static function setAccessControlPolicy($bucket, $uri = '', $acp = array()) {
        $dom = new DOMDocument;
        $dom->formatOutput = true;
        $accessControlPolicy = $dom->createElement('AccessControlPolicy');
        $accessControlList = $dom->createElement('AccessControlList');

        // It seems the owner has to be passed along too
        $owner = $dom->createElement('Owner');
        $owner->appendChild($dom->createElement('ID', $acp['owner']['id']));
        $owner->appendChild($dom->createElement('DisplayName', $acp['owner']['name']));
        $accessControlPolicy->appendChild($owner);

        foreach ($acp['acl'] as $g) {
            $grant = $dom->createElement('Grant');
            $grantee = $dom->createElement('Grantee');
            $grantee->setAttribute('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance');
            if (isset($g['id'])) { // CanonicalUser (DisplayName is omitted)
                $grantee->setAttribute('xsi:type', 'CanonicalUser');
                $grantee->appendChild($dom->createElement('ID', $g['id']));
            } elseif (isset($g['email'])) { // AmazonCustomerByEmail
                $grantee->setAttribute('xsi:type', 'AmazonCustomerByEmail');
                $grantee->appendChild($dom->createElement('EmailAddress', $g['email']));
            } elseif ($g['type'] == 'Group') { // Group
                $grantee->setAttribute('xsi:type', 'Group');
                $grantee->appendChild($dom->createElement('URI', $g['uri']));
            }
            $grant->appendChild($grantee);
            $grant->appendChild($dom->createElement('Permission', $g['permission']));
            $accessControlList->appendChild($grant);
        }

        $accessControlPolicy->appendChild($accessControlList);
        $dom->appendChild($accessControlPolicy);

        $rest = new S3Request('PUT', $bucket, '');
        $rest->setParameter('acl', null);
        $rest->data = $dom->saveXML();
        $rest->size = strlen($rest->data);
        $rest->setHeader('Content-Type', 'application/xml');
        $rest = $rest->getResponse();
        if ($rest->error === false && $rest->code !== 200)
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::setAccessControlPolicy({$bucket}, {$uri}): [%s] %s",
            $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }
        return true;
    }


    /**
    * Get object or bucket Access Control Policy
    *
    * Currently this will trigger an error if there is no ACL on an object (will fix soon)
    *
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @return mixed | false
    */
    public static function getAccessControlPolicy($bucket, $uri = '') {
        $rest = new S3Request('GET', $bucket, $uri);
        $rest->setParameter('acl', null);
        $rest = $rest->getResponse();
        if ($rest->error === false && $rest->code !== 200)
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::getAccessControlPolicy({$bucket}, {$uri}): [%s] %s",
            $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }

        $acp = array();
        if (isset($rest->body->Owner, $rest->body->Owner->ID, $rest->body->Owner->DisplayName)) {
            $acp['owner'] = array(
                'id' => (string)$rest->body->Owner->ID, 'name' => (string)$rest->body->Owner->DisplayName
            );
        }
        if (isset($rest->body->AccessControlList)) {
            $acp['acl'] = array();
            foreach ($rest->body->AccessControlList->Grant as $grant) {
                foreach ($grant->Grantee as $grantee) {
                    if (isset($grantee->ID, $grantee->DisplayName)) // CanonicalUser
                        $acp['acl'][] = array(
                            'type' => 'CanonicalUser',
                            'id' => (string)$grantee->ID,
                            'name' => (string)$grantee->DisplayName,
                            'permission' => (string)$grant->Permission
                        );
                    elseif (isset($grantee->EmailAddress)) // AmazonCustomerByEmail
                        $acp['acl'][] = array(
                            'type' => 'AmazonCustomerByEmail',
                            'email' => (string)$grantee->EmailAddress,
                            'permission' => (string)$grant->Permission
                        );
                    elseif (isset($grantee->URI)) // Group
                        $acp['acl'][] = array(
                            'type' => 'Group',
                            'uri' => (string)$grantee->URI,
                            'permission' => (string)$grant->Permission
                        );
                    else continue;
                }
            }
        }
        return $acp;
    }


    /**
    * Delete an object
    *
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @return mixed
    */
    public static function deleteObject($bucket = '', $uri = '') {
        $rest = new S3Request('DELETE', $bucket, $uri);
        $rest = $rest->getResponse();
        if ($rest->error === false && $rest->code !== 204)
            $rest->error = array('code' => $rest->code, 'message' => 'Unexpected HTTP status');
        if ($rest->error !== false) {
            trigger_error(sprintf("S3::deleteObject(): [%s] %s", $rest->error['code'], $rest->error['message']), E_USER_WARNING);
            return false;
        }
        return true;
    }


    /**
    * Get MIME type for file
    *
    * @internal Used to get mime types
    * @param string &$file File path
    * @return string
    */
    public static function __getMimeType(&$file) {
        $type = false;
        // Fileinfo documentation says fileinfo_open() will use the
        // MAGIC env var for the magic file
        if (extension_loaded('fileinfo') && isset($_ENV['MAGIC']) &&
        ($finfo = finfo_open(FILEINFO_MIME, $_ENV['MAGIC'])) !== false) {
            if (($type = finfo_file($finfo, $file)) !== false) {
                // Remove the charset and grab the last content-type
                $type = explode(' ', str_replace('; charset=', ';charset=', $type));
                $type = array_pop($type);
                $type = explode(';', $type);
                $type = array_shift($type);
            }
            finfo_close($finfo);

        // If anyone is still using mime_content_type()
        } elseif (function_exists('mime_content_type'))
            $type = mime_content_type($file);

        if ($type !== false && strlen($type) > 0) return $type;

        // Otherwise do it the old fashioned way
        static $exts = array(
            'jpg' => 'image/jpeg', 'gif' => 'image/gif', 'png' => 'image/png',
            'tif' => 'image/tiff', 'tiff' => 'image/tiff', 'ico' => 'image/x-icon',
            'swf' => 'application/x-shockwave-flash', 'pdf' => 'application/pdf',
            'zip' => 'application/zip', 'gz' => 'application/x-gzip',
            'tar' => 'application/x-tar', 'bz' => 'application/x-bzip',
            'bz2' => 'application/x-bzip2', 'txt' => 'text/plain',
            'asc' => 'text/plain', 'htm' => 'text/html', 'html' => 'text/html',
            'xml' => 'text/xml', 'xsl' => 'application/xsl+xml',
            'ogg' => 'application/ogg', 'mp3' => 'audio/mpeg', 'wav' => 'audio/x-wav',
            'avi' => 'video/x-msvideo', 'mpg' => 'video/mpeg', 'mpeg' => 'video/mpeg',
            'mov' => 'video/quicktime', 'flv' => 'video/x-flv', 'php' => 'text/x-php'
        );
        $ext = strToLower(pathInfo($file, PATHINFO_EXTENSION));
        return isset($exts[$ext]) ? $exts[$ext] : 'application/octet-stream';
    }


    /**
    * Generate the auth string: "AWS AccessKey:Signature"
    *
    * This uses the hash extension if loaded
    *
    * @internal Signs the request
    * @param string $string String to sign
    * @return string
    */
    public static function __getSignature($string) {
        return 'AWS '.self::$__accessKey.':'.base64_encode(extension_loaded('hash') ?
        hash_hmac('sha1', $string, self::$__secretKey, true) : pack('H*', sha1(
        (str_pad(self::$__secretKey, 64, chr(0x00)) ^ (str_repeat(chr(0x5c), 64))) .
        pack('H*', sha1((str_pad(self::$__secretKey, 64, chr(0x00)) ^
        (str_repeat(chr(0x36), 64))) . $string)))));
    }


}

final class S3Request {
    private $verb, $bucket, $uri, $resource = '', $parameters = array(),
    $amzHeaders = array(), $headers = array(
        'Host' => '', 'Date' => '', 'Content-MD5' => '', 'Content-Type' => ''
    );
    public $fp = false, $size = 0, $data = false, $response;


    /**
    * Constructor
    *
    * @param string $verb Verb
    * @param string $bucket Bucket name
    * @param string $uri Object URI
    * @return mixed
    */
    function __construct($verb, $bucket = '', $uri = '') {
        $this->verb = $verb;
        $this->bucket = strtolower($bucket);
        $this->uri = $uri !== '' ? '/'.$uri : '/';

        if ($this->bucket !== '') {
            $this->bucket = explode('/', $this->bucket);
            $this->resource = '/'.$this->bucket[0].$this->uri;
            $this->headers['Host'] = $this->bucket[0].'.s3.amazonaws.com';
            $this->bucket = implode('/', $this->bucket);
        } else {
            $this->headers['Host'] = 's3.amazonaws.com';
            if (strlen($this->uri) > 1)
                $this->resource = '/'.$this->bucket.$this->uri;
            else $this->resource = $this->uri;
        }
        $this->headers['Date'] = gmdate('D, d M Y H:i:s T');

        $this->response = new STDClass;
        $this->response->error = false;
    }


    /**
    * Set request parameter
    *
    * @param string $key Key
    * @param string $value Value
    * @return void
    */
    public function setParameter($key, $value) {
        $this->parameters[$key] = $value;
    }


    /**
    * Set request header
    *
    * @param string $key Key
    * @param string $value Value
    * @return void
    */
    public function setHeader($key, $value) {
        $this->headers[$key] = $value;
    }


    /**
    * Set x-amz-meta-* header
    *
    * @param string $key Key
    * @param string $value Value
    * @return void
    */
    public function setAmzHeader($key, $value) {
        $this->amzHeaders[$key] = $value;
    }


    /**
    * Get the S3 response
    *
    * @return object | false
    */
    public function getResponse() {
        $query = '';
        if (sizeof($this->parameters) > 0) {
            $query = substr($this->uri, -1) !== '?' ? '?' : '&';
            foreach ($this->parameters as $var => $value)
                if ($value == null || $value == '') $query .= $var.'&';
                else $query .= $var.'='.$value.'&';
            $query = substr($query, 0, -1);
            $this->uri .= $query;
            if (isset($this->parameters['acl']) || !isset($this->parameters['logging']))
                $this->resource .= $query;
        }
        $url = (extension_loaded('openssl')?'https://':'http://').$this->headers['Host'].$this->uri;
        //var_dump($this->bucket, $this->uri, $this->resource, $url);

        // Basic setup
        $curl = curl_init();
        curl_setopt($curl, CURLOPT_USERAGENT, 'S3/php');
        curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 0);
        curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, 0);
        curl_setopt($curl, CURLOPT_URL, $url);

        // Headers
        $headers = array(); $amz = array();
        foreach ($this->amzHeaders as $header => $value)
            if (strlen($value) > 0) $headers[] = $header.': '.$value;
        foreach ($this->headers as $header => $value)
            if (strlen($value) > 0) $headers[] = $header.': '.$value;
        foreach ($this->amzHeaders as $header => $value)
            if (strlen($value) > 0) $amz[] = strToLower($header).':'.$value;
        $amz = (sizeof($amz) > 0) ? " ".implode(" ", $amz) : '';

        // Authorization string
        $headers[] = 'Authorization: ' . S3::__getSignature(
            $this->verb." ".
            $this->headers['Content-MD5']." ".
            $this->headers['Content-Type']." ".
            $this->headers['Date'].$amz." ".$this->resource
        );

        curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($curl, CURLOPT_HEADER, false);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, false);
        curl_setopt($curl, CURLOPT_WRITEFUNCTION, array(&$this, '__responseWriteCallback'));
        curl_setopt($curl, CURLOPT_HEADERFUNCTION, array(&$this, '__responseHeaderCallback'));

        // Request types
        switch ($this->verb) {
            case 'GET': break;
            case 'PUT':
                if ($this->fp !== false) {
                    curl_setopt($curl, CURLOPT_PUT, true);
                    curl_setopt($curl, CURLOPT_INFILE, $this->fp);
                    if ($this->size > 0)
                        curl_setopt($curl, CURLOPT_INFILESIZE, $this->size);
                } elseif ($this->data !== false) {
                    curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'PUT');
                    curl_setopt($curl, CURLOPT_POSTFIELDS, $this->data);
                    if ($this->size > 0)
                        curl_setopt($curl, CURLOPT_BUFFERSIZE, $this->size);
                } else
                    curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'PUT');
            break;
            case 'HEAD':
                curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'HEAD');
                curl_setopt($curl, CURLOPT_NOBODY, true);
            break;
            case 'DELETE':
                curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'DELETE');
            break;
            default: break;
        }

        // Execute, grab errors
        if (curl_exec($curl))
            $this->response->code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
        else
            $this->response->error = array(
                'code' => curl_errno($curl),
                'message' => curl_error($curl),
                'resource' => $this->resource
            );

        @curl_close($curl);

        // Parse body into XML
        if ($this->response->error === false && isset($this->response->headers['type']) &&
        $this->response->headers['type'] == 'application/xml' && isset($this->response->body)) {
            $this->response->body = simplexml_load_string($this->response->body);

            // Grab S3 errors
            if (!in_array($this->response->code, array(200, 204)) &&
            isset($this->response->body->Code, $this->response->body->Message)) {
                $this->response->error = array(
                    'code' => (string)$this->response->body->Code,
                    'message' => (string)$this->response->body->Message
                );
                if (isset($this->response->body->Resource))
                    $this->response->error['resource'] = (string)$this->response->body->Resource;
                unset($this->response->body);
            }
        }

        // Clean up file resources
        if ($this->fp !== false && is_resource($this->fp)) fclose($this->fp);

        return $this->response;
    }


    /**
    * CURL write callback
    *
    * @param resource &$curl CURL resource
    * @param string &$data Data
    * @return integer
    */
    private function __responseWriteCallback(&$curl, &$data) {
        if ($this->response->code == 200 && $this->fp !== false)
            return fwrite($this->fp, $data);
        else
            $this->response->body .= $data;
        return strlen($data);
    }


    /**
    * CURL header callback
    *
    * @param resource &$curl CURL resource
    * @param string &$data Data
    * @return integer
    */
    private function __responseHeaderCallback(&$curl, &$data) {
        if (($strlen = strlen($data)) <= 2) return $strlen;
        if (substr($data, 0, 4) == 'HTTP')
            $this->response->code = (int)substr($data, 9, 3);
        else {
            list($header, $value) = explode(': ', trim($data));
            if ($header == 'Last-Modified')
                $this->response->headers['time'] = strtotime($value);
            elseif ($header == 'Content-Length')
                $this->response->headers['size'] = (int)$value;
            elseif ($header == 'Content-Type')
                $this->response->headers['type'] = $value;
            elseif ($header == 'ETag')
                $this->response->headers['hash'] = substr($value, 1, -1);
            elseif (preg_match('/^x-amz-meta-.*$/', $header))
                $this->response->headers[$header] = is_numeric($value) ? (int)$value : $value;
        }
        return $strlen;
    }

}
?>

function.php

Note that you will need to replace "your-bucket-name", "path/to/your/file.jpg", "YOUR_ACCESS_KEY", and "YOUR_SECRET_KEY" with the appropriate values for your S3 bucket and AWS account.

You can also use the AWS SDK for PHP to list, retrieve, and delete objects from an S3 bucket and create and delete buckets. The SDK provides a comprehensive set of APIs for working with S3 buckets in PHP.

define(AWS_ACCESS_KEY, "YOUR_ACCESS_KEY");
define(AWS_SECRET_KEY, "YOUR_SECRET_KEY");
define(APP_BUCKET,"BUCKET_NAME");
define(APP_FILE_PREFIX, "ABC");
define(REMOTE_FOLDER_URL,"https://".APP_BUCKET.".s3.amazonaws.com");

   <?php
    
     define(AWS_ACCESS_KEY, "YOUR_ACCESS_KEY");
     define(AWS_SECRET_KEY, "YOUR_SECRET_KEY");
     define(APP_BUCKET,"BUCKET_NAME");
     define(APP_FILE_PREFIX, "ABC");
     define(REMOTE_FOLDER_URL,"https://".APP_BUCKET.".s3.amazonaws.com");
   
    function upload_file_to_s3($local_file, $uploadfilename)
    {
        if (!class_exists('S3'))require_once('S3.php');
        $s3 = new S3(AWS_ACCESS_KEY, AWS_SECRET_KEY);
        $s3->putBucket(APP_BUCKET, S3::ACL_PUBLIC_READ);
       
        try
        {
            $s3->putObjectFile($local_file, APP_BUCKET, $uploadfilename, S3::ACL_PUBLIC_READ);
            unset($s3);
            return true;
        }
        catch(Exception $e)
        {
            echo $e->getMessage();
            unset($s3);
            return false;
        }
    }
   
   
?>

upload.php

<?php
include_once("function.php");


$msg="";
if(isset($_POST['submit'])){
 
 $countfiles = count($_FILES['files']['name']);
 
 for($i=0;$i<$countfiles;$i++){
   $filename = $_FILES['files']['name'][$i];
 
 
   $types = array('image/jpeg','image/gif','image/png','image/jpg','application/pdf');
        $file_img_profile = basename( $_FILES['files']['name'][$i]);
        $handle = realpath($_FILES["files"]["tmp_name"][$i]);
        
        if (in_array($_FILES['files']['type'][$i], $types))
        {
            $temp_file = $_FILES['files']['tmp_name'][$i];
            $new_file_name = $_FILES['files']['name'][$i];
            $up_time=mktime();   
            $new_file_name=str_replace(" ","_",$new_file_name);
            $new_file_name=APP_FILE_PREFIX."_".substr(md5(str_shuffle($_SERVER['REMOTE_ADDR'].mktime())),2,8)."_".$new_file_name;
            upload_file_to_s3($temp_file, $new_file_name);
           $msg=" Upload Successfully";

            
        }
          
    
 }
}

?>