Corregir error “413 Request Entity Too Large” cuando se suben temas de WordPress a tu servidor

Problema

Cuando trato de subir un archivo un poco “pesado” a mi servidor (por ejemplo un tema de WordPress) estoy recibiendo el error 413 Request Entity Too Large

Explicación del error

Este error sucede porque en la configuración de tu servidor web nginx hay una limitante en cuanto al tamaño del archivo que se puede subir; este tamaño usualmente se especifica en megabytes y normalmente está acotado a sólo 2 MB, lo cual es muy poco para un tema de WordPress por ejemplo.

Solución

Lo que debemos hacer son dos cosas:

Paso 1. Modifica la configuración de nginx

Modificar nuestra configuración de nginx para que tenga un parámetro con  menos limitante en cuanto al tamaño en megabytes que podemos subir a nuestro servidor usando un navegador web.

Para ello, procedamos con lo siguiente:

Ingresa en modo terminal en tu servidor y abre el siguiente archivo (previo respaldo del mismo):

sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup
sudo nano /etc/nginx/nginx.conf

Localiza el bloque referente a la configuración http y agrega la siguientes líneas:

# To avoid error when uploading files added Alex Arriaga
client_max_body_size 32M;

Como notarás ahora estamos indicando un tamaño de cuerpo de las peticiones de 32 MB (es decir, podrías subir por ejemplo un archivo ZIP de aproximadamente ese tamaño).

Después de la modificación de tu archivo más o menos se contendrá algo como esto:

http {

        ##
        # Basic Settings
        ##

        sendfile on;
        tcp_nopush on;
        tcp_nodelay on;
        keepalive_timeout 65;
        types_hash_max_size 2048;
        # server_tokens off;

        server_names_hash_bucket_size 64;
        # server_name_in_redirect off;

        include /etc/nginx/mime.types;
        default_type application/octet-stream;

        # To avoid error when uploading files added Alex Arriaga
        client_max_body_size 32M;

        # Aquí habrá más líneas de configuración...
        # ...


}

Paso 2. Verifica sintaxis y recarga la configuración

Primero verifiquemos que NO tenemos errores de sintaxis en nuestro archivo de configuración. Eso se hace fácilmente con el siguiente comando.

sudo service nginx configtest

En caso de tener algún error, puedes ver qué pasa usando este comando:

sudo nginx -t

Si no ves algún error, entonces es momento de recargar la configuración de nginx usando:

sudo service nginx reload

Paso 3. Modifiquemos nuestro archivo php.ini para que coincida con el parámetro de nginx

El archivo php.ini es un archivo de configuración de PHP (el lenguaje de servidor con el que están hechos muchos CMS -como WordPress y Drupal- y frameworks -como Laravel y CakePHP-.

La localización de este archivo puede variar, la forma más fácil de saber dónde está este archivo, es creando un archivo info.php en tu servidor y accederlo desde tu portal de internet (ya sea en local o en un dominio real).

Veamos cómo hacer esto:

# Esta sería la ruta donde está tu proyecto
cd /path/to/your/project/or/app
sudo nano info.php

Coloca en este archivo la siguiente línea de código PHP:

<?php phpinfo(); ?>

Ahora si tu sitio de internet o aplicación está en http://example.com, entonces podríamos visitar http://example.com/info.php y veríamos una tabla de color morado con datos como estos:

Busca ahí la parte donde diga “Configuration File (php.ini) Path” y con eso sabrás dónde está tu archivo php.ini. En nuestro caso está en la ruta:

nano /etc/php/7.0/fpm/php.ini
Al terminar estas configuraciones recuerda eliminar el archivo info.php ya que expone DEMASIADA información que un atacante pudiera usar para hacer cosas malas en tu sitio.

Perfecto, ahora abramos este archivo y modifiquemos esta línea:

upload_max_filesize = 2M

Para abrir tu archivo simplemente usa algún editor como nano:

sudo nano /etc/php/7.0/fpm/php.ini

Después de modificar tu archivo, éste se vería con algunas líneas como estas:

; Maximum allowed size for uploaded files.
; http://php.net/upload-max-filesize
; upload_max_filesize = 2M

; Esta es nuestra configuración cambiada a 32M
upload_max_filesize = 32M

Guarda tu archivo y continuemos.

Paso 4. Reiniciemos PHP-FPM

Este paso podría NO aplicar a tu servidor, ya que depende si uses PHP-FPM en caso de que no, con el simple reinicio de Nginx debería ser suficiente.

# Restart Nginx
sudo service nginx restart

# Restart PHP-PFM
sudo /etc/init.d/php7.0-fpm restart

Y listo, ahora si intentas subir tu archivo, ya deberías tener permitidos archivos con un tamaño mayor (32 M).

Saludos cordiales y nos vemos en otro momento.

Por cierto ¿ya viste todos los cursos que tenemos en Webtraining.Zone? Si no, aquí puedes ver TODO el catálogo de cursos premium con los cuales podrás dar el siguiente paso en tu carrera como Desarrollador, Ingeniero o Arquitecto de la Web.

¿Cuándo se creó Node.js?

Hoy una de nuestras webtrainees: Alejandra, nos comentaba que en su país había visto vacantes que pedían alrededor de 3 años de experiencia en Node.js. Entonces varias preguntas vinieron a su mente:

¿Es posible que alguien tenga experiencia de 3 años con Node.js?

Sí, si es posible; eso significaría que fue una de las primeras personas que comenzaron a utilizar Node.js en el ámbito enterprise. Node.js históricamente fue presentado por su creador Ryan Dahl por primera vez en la JSConf 2009 el 08 de noviembre de ese año, estas son las diapositivas originales usadas durante esa conferencia .

Ahora bien, si encuentras a una persona con tres años de experiencia en Node.js, eso significa que realmente es alguien con bastante experiencia en él ¡no lo dejes ir!

¿Te gustaría ver la conferencia original? Aquí la tienes.

¿En qué año se empezó a implementar Node.js?

Podríamos decir que Node.js despegó formalmente en 2013 que es cuando sale version 0.10.x, aquí te dejamos la tabla oficial tomada de nuestra querida Wikipedia.

Release Code name Release date LTS status Active LTS start Maintenance start Maintenance end
v0.10.x 2013-03-11 Old version, no longer supported: End-of-life 2015-10-01 2016-10-31
v0.12.x 2015-02-06 Old version, no longer supported: End-of-life 2016-04-01 2016-12-31
4.x Argon 2015-09-08 Older version, yet still supported: Maintenance 2015-10-01 2017-04-01 April 2018
5.x 2015-10-29 No LTS N/A
6.x Boron 2016-04-26 Current stable version: Active 2016-10-18 April 2018 April 2019
7.x 2016-10-25 No LTS N/A
8.x Carbon[65] 2017-05-30 Current stable version: Active 2017-10-31 April 2019 December 2019
9.x 2017-10-31 No LTS N/A
10.x Future release: Pending October 2018 April 2020 April 2021

Cuéntame ¿has usado Node.js para hacer cosas geniales?

Saludos.

Integración de Paypal a Laravel 5.2

Paypal es una forma muy popular de pago. La mayoría de las personas la seleccionan porque esta es segura y simple de usar. Si deseas integrar Paypal express checkout a tu aplicación de Laravel 5.2, solamente tienes que seguir los siguientes pasos.

1.- Instalación. En este paso necesitas instalar nestshell/paypal, solo ejecuta el siguiente comando en tu terminal

composer require netshell/paypal dev-master

2.- Añadir las siguientes rutas al archivo de config/app.php.

return [
	......
	$provides => [
		......
		......,
		'Netshell\Paypal\PaypalServiceProvider'
	],
	$aliases => [
		.....
		.....,
		'Paypal' => 'Netshell\Paypal\Facades\Paypal'
	]
]

3.- Credenciales para modo Sandbox y Live de Paypal

En este paso ya debes tener tu client_id y tu código secreto proporcionados por la herramienta sandbox de paypal .  Para ello ya debes contar con una tipo empresarial en Paypal.

Te explico de manera rápida en que parte de Paypal adquieres estos códigos. Si ya hiciste login en tu cuenta tipo developer (sandbox), ve a los siguientes menús del lado izquierdo: My Apps & Credentials , dirígete hacia la opción REST API apps y da clic en el botón Create App.

Aquí están las famosas credenciales 

Ahora que ya tienes creadas tus credenciales, necesitas añadirlas en el archivo de config\services

return [
'paypal' => [
        'client_id' => 'xxx',
        'secret' => 'xxx',
    ],
];

4.- Añadir rutas al archivo de route.php

En este paso vamos a añadir las rutas necesarias para la comunicación en app/http/routes.php

Route::group(['middleware' => ['web']], function () {
 Route::get('payPremium', ['as'=>'payPremium','uses'=>'PaypalController@payPremium']);    
Route::post('getCheckout', ['as'=>'getCheckout','uses'=>'PaypalController@getCheckout']);
    Route::get('getDone', ['as'=>'getDone','uses'=>'PaypalController@getDone']);
    Route::get('getCancel', ['as'=>'getCancel','uses'=>'PaypalController@getCancel']);
});

5.- Ahora que ya creaste las rutas, es necesario generar nuestro Controller

php artisan make:controller PaypalController

Vamos al código fuente de nuestro PaypalController app/http/Controllers/PaypalController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Requests;
use Paypal;
use App\User;
use Illuminate\Support\Facades\Auth;

class PaypalController extends Controller
{
    private $_apiContext;

    public function __construct()
    {
    	 $this->_apiContext = PayPal::ApiContext(
            config('services.paypal.client_id'),
            config('services.paypal.secret'));

    	//Aquí guarde una configuración para mis credenciales de Sandbox
        /*$this->_apiContext->setConfig(array(
            'mode' => 'sandbox',
            'service.EndPoint' => 'https://api.sandbox.paypal.com',
            'http.ConnectionTimeOut' => 30,
            'log.LogEnabled' => true,
            'log.FileName' => storage_path('logs/paypal.log'),
            'log.LogLevel' => 'FINE'
        ));*/

        //Config live
        $this->_apiContext->setConfig(array(
            'mode' => 'live',
            'service.EndPoint' => 'https://api.paypal.com',
            'http.ConnectionTimeOut' => 30,
            'log.LogEnabled' => true,
            'log.FileName' => storage_path('logs/paypal.log'),
            'log.LogLevel' => 'FINE'
        ));
    }

    public function getCheckout(Request $request)
	{
        $user         = Auth::user(); 
        $id_user      = $user->id;
        $id_purchased_item    = $request->input('id_purchased_item'); //producto que me estan comprando
        $invoice      = $id_user.'-'.$id_purchased_item.'-'.$this->random(5);//generación de invoice aleatorio
        $descripcion  = $request->input('description');
        $quantity     = $request->input('quantity');//cantidad de productos adquiridos
        $total_amount = $request->input('amount');
        $currency     = $request->input('currency_code');//tipo de moneda

	    $payer = PayPal::Payer();
	    $payer->setPaymentMethod('paypal');

	    $item1 = PayPal::item();
        $item1->setName($descripcion)
                ->setDescription($descripcion)
                ->setCurrency($currency)
                ->setQuantity(1)
                ->setPrice($total_amount);

        $itemList = PayPal::itemList();
        $itemList->setItems(array($item1));


        // ### Cantidad
        // Especificando la cantidad del pago
        // Se pueden añadir detalles adicionales como 
        // shipping, tax.
        // Todo estó para que en paypal aparezca desglosado
        // como si de un carrito de compra se tratará
        $amount = PayPal::amount();
        $amount->setCurrency($currency)
            ->setTotal($total_amount);

        // ### Transacción
        // Para quién es el pago y quién lo está pagando. 
        $transaction = PayPal::transaction();
        $transaction->setAmount($amount)
            ->setItemList($itemList)
            ->setDescription("Descripción")
            ->setInvoiceNumber($invoice);

        // ### urls de redirección
        // Rutas a las que será redirigido el comprador después de un pago 
        // aprobado / cancelación

        $redirectUrls = PayPal:: RedirectUrls();
	    $redirectUrls->setReturnUrl(route('getDone'));
	    $redirectUrls->setCancelUrl(route('getCancel'));

        // ### Pago
        // Creamos el pago, para establecer la venta

        $payment = PayPal::Payment();
	    $payment->setIntent('sale');
	    $payment->setPayer($payer);
	    $payment->setRedirectUrls($redirectUrls);
	    $payment->setTransactions(array($transaction));

	    $response = $payment->create($this->_apiContext);
	    $redirectUrl = $response->links[1]->href;
	    
	    return redirect()->to( $redirectUrl );

	}

	public function getDone(Request $request)
	{
        $id               = $request->get('paymentId');
        $token            = $request->get('token');
        $payer_id         = $request->get('PayerID');
        $payment          = PayPal::getById($id, $this->_apiContext);
        $paymentExecution = PayPal::PaymentExecution();

        $paymentExecution->setPayerId($payer_id);
        $executePayment = $payment->execute($paymentExecution, $this->_apiContext);

	    return view("payments.payment-done");
	}


	public function getCancel()
	{
	   return view("payment-cancel", compact("executePayment"));
	}

      /*generación del invoice para paypal */
      public function random($qtd){
 
       $caracteres = 'ABCDEFGHIJKLMOPQRSTUVXWYZ0123456789'; 
       $cantidad_de_caracteres = strlen($caracteres); 
       $cantidad_de_caracteres--; 

       $num_random = NULL; 
       for($x=1;$x<=$qtd;$x++){ 
        $posicion = rand(0,$cantidad_de_caracteres); 
        $num_random .= substr($caracteres,$posicion,1); 
       } 

      return $num_random; 
     } 
}

 

 

 

 

El concepto de namespace en PHP

¿Te acuerdas cuando tu maestra de primaria te decía que tus libretas deberían estar bien ordenadas de acuerdo a la materia de la que trataran?

Pues bien los namespaces son una forma de organización de código que tenemos disponible en PHP; si vienes de un mundo parecido a Java seguramente recuerdas el concepto de paquete o package, que básicamente se encargaba de agrupar varias clases semántica o lógicamente relacionadas bajo un mismo folder (directorio físico o lógico).

Esa misma idea la tenemos en PHP y para usarlos sólo necesitas utilizar la palabra reservada namespace seguido del nombre que desees, por ejemplo si queremos que la clase User sea parte del espacio de nombres App, usaríamos la siguiente sintaxis.

namespace App;

class User {

}

Ventajas de los namespaces de PHP

  • Evitan colisiones entre clases; por ejemplo imagina que estás integrando dos sistemas diferentes bajo una misma aplicación pero ambos sistemas tienen una clase User. Sin usar namespaces no podrías user ambas clases en el mismo archivo PHP.
  • Capacidad de utilizar un alias cuando importas tus clases con el mismo nombre. Es decir, usando namespaces puedes definir un alias fácilmente como en el siguiente ejemplo:
namespace App;

use Webtraining\Auth\Models\User as WebtrainingUser;

class User {
    public function copyUser(WebtrainingUser $user) {
       // Some logic goes here!
    }
}

Para más información sobre aliasing/importing visita este artículo Using namespaces: Aliasing/Importing

Y aquí tienes el Namespaces overview de la documentación oficial.

Que tengas un excelente día.

Comandos más usados de Laravel PHP Artisan

Cuando nos encontramos trabajando con Laravel una de las mejores herramientas que tenemos a nuestra disposición es el generador llamado artisan, aquí te dejamos nuestra lista de los comandos que más usamos en el día a día:

Crear una tabla

# Crear la tabla "posts"
php artisan make:migration create_posts_table --create posts 
php artisan migrate

Modificar una tabla existente

# Agregar el campo "summary" a la tabla "posts"
php artisan make:migration add_summary_to_posts_table --table="posts"

# Agregar varios campos nuevos a la tabla "users"
php artisan make:migration add_fields_to_users_table --table="users"

php artisan migrate

Generar una llave para hashing

php artisan key:generate

Crear un middleware

# Crear un middleware para verificiar si el usuario tiene una sesión
php artisan make:middleware HasUserASession

Crear un modelo

# Crear modelo Post
php artisan make:model Post

Crear un controlador

# Crear el controlador PostsController compatible con REST (resource) 
php artisan make:controller PostsController --resource

Generar código boilerplate para autenticación de usuarios

Este comando debería ejecutarse lo más pronto al iniciar tu proyecto ya que re-escribirá tus layouts y controladores de Autenticación y Usuarios

php artisan make:auth