Gestión de paquetes en Laravel

En este artículo, seguiremos adelante y exploraremos la función de administración de paquetes en el marco Laravel. En el transcurso del artículo, veremos un ejemplo del mundo real para demostrar el propósito del artículo..

La administración de paquetes en Laravel es una característica importante que le permite agrupar una parte de la funcionalidad para que se pueda distribuir fácilmente. Además, siempre puedes publicar tu paquete en repositorios como Packagist y GitHub que permitan a otros desarrolladores beneficiarse de tu paquete..

Para demostrar el concepto, crearemos una página de ejemplo en Laravel que carga una imagen en la nube de Amazon S3. En lugar de seguir el flujo habitual, lo desarrollaremos como un paquete que se puede distribuir y mantener fácilmente..

Antes de seguir adelante, asumo que ya está familiarizado con el marco de trabajo de Laravel ya que no voy a entrar en los detalles de los conceptos básicos de Laravel..

Además, debe tener una cuenta de AWS válida y las credenciales para acceder a la API de Amazon a fin de seguir el ejemplo de este artículo. Por lo tanto, asegúrese de que configura eso primero.

Con todo a la mano, estamos listos para sumergirnos en el desarrollo real.

Configuración de los archivos del paquete

Veamos rápidamente la lista de archivos que implementaremos a lo largo de este tutorial..

compositor.json: Necesitamos agregar el mapeo de clase de nuestro paquete en el existente compositor.json archivo en la raíz del paquete.
config / app.php: Este es el archivo existente que usaremos para agregar una entrada de nuestro proveedor de servicios personalizado para que podamos cargar vistas y rutas usando ese archivo.
compositor.json: Este es el paquete específico compositor.json archivo si desea distribuir el paquete con otros.
paquetes / envato / aws / src / Providers / AwsServiceProvider.php: El archivo habitual del proveedor de servicios Laravel que se utilizará para cargar otros componentes del paquete.
paquetes / envato / aws / src / route / web.php: Carga las rutas personalizadas de nuestro paquete..
packages / envato / aws / src / Controllers / AwsController.php: Este es el archivo del controlador que maneja la lógica de la aplicación de nuestro paquete.
paquetes / envato / aws / src / views / upload.blade.php: El archivo de vista que maneja la lógica de representación.

No se preocupe si aún no tiene mucho sentido, ya que lo discutiremos en detalle a medida que avancemos..

Configuración de los requisitos previos

Como comentamos anteriormente, nuestro paquete implementa el caso de uso de la carga de archivos a la nube de Amazon S3. En esta sección, veremos los requisitos previos que deben configurarse para ejecutar nuestro paquete correctamente..

Como desarrollador de Laravel, debes estar familiarizado con Flysystem, que proporciona una buena capa de abstracción para interactuar con el sistema de archivos. Proporciona controladores fáciles de usar para que pueda interactuar fácilmente sin importar el tipo de sistema de archivos con el que esté trabajando, ya sea el sistema de archivos local o el sistema de nube AWS S3..

Para habilitar el soporte del sistema de archivos en la nube de Amazon S3 con Flysystem, debe instalar el paquete del editor del adaptador correspondiente.

Continúe y ejecute el siguiente comando de composición desde la raíz de su proyecto para instalar el paquete flysystem-aws-s3-v3.

$ compositor require league / flysystem-aws-s3-v3

Tras la ejecución exitosa de ese comando, ahora puede utilizar Laravel Flysystem para interactuar con el sistema de archivos en la nube de Amazon S3 de la misma manera que lo habría usado para el sistema de archivos local..

Ahora, vamos a tirar rápidamente en el config / filesystems.php archivo para ver la configuración proporcionada para el sistema de archivos Amazon S3.

... 'disks' => ['local' => ['driver' => 'local', 'root' => storage_path ('app'),], 'public' => ['driver' => 'local' , 'root' => storage_path ('app / public'), 'url' => env ('APP_URL'). '/ storage', 'visibilidad' => 'public',], 's3' => [' driver '=>' s3 ',' key '=> env (' AWS_KEY '),' secret '=> env (' AWS_SECRET '),' region '=> env (' AWS_REGION '),' bucket '=> env ('AWS_BUCKET'),],], ...

Como puede ver, la configuración ya está implementada para el Amazon S3; es sólo que necesitamos establecer adecuada ENV variables en el .env expediente.

Continúa y agrega las siguientes variables en tu .env expediente.

AWS_KEY =  AWS_KEY_VALUE AWS_SECRET =  AWS_SECRET_VALUE AWS_REGION =  AWS_REGION_VALUE AWS_BUCKET =  AWS_BUCKET_VALUE AWS_CDN_URL =  AWS_CDN_URL_VALUE

Por supuesto, debe reemplazar los marcadores de posición con sus valores reales. Ahora, está listo para usar el adaptador AWS S3 de Flysystem en su aplicación Laravel.

Pasando por los archivos del paquete

Para crear su propio paquete Laravel, lo primero es crear una estructura de directorios adecuada que refleje las convenciones del sistema Laravel. Supongo que ya estás ejecutando una aplicación Laravel básica; de hecho, el predeterminado Blog la aplicación va a hacer también.

Sigue adelante y crea el paquetes Directorio en la raíz de su aplicación. Teniendo en cuenta que va a distribuir su paquete con otros, la estructura preferida de su paquete debe ser vendor_name / package_name.

Siguiendo esa convención, vamos a seguir adelante y crear una envato / aws directorio bajo el paquetes directorio. Como habrás adivinado, envato es el nombre del vendedor, y aws representa el nombre del paquete en sí. Finalmente, vamos a crear una paquetes / envato / aws / src Directorio que contiene los archivos fuente de nuestro paquete..

Ahora, necesitamos informar a Laravel sobre nuestro nuevo paquete. Sigue adelante y abre el compositor.json archivo en la raíz de su aplicación Laravel y agregue el "Envato \\ Aws \\": "packages / envato / aws / src" entrada en la sección de carga automática como se muestra a continuación.

... "autoload": "classmap": ["database"], "psr-4": "App \\": "app /", "Envato \\ Aws \\": "packages / envato / aws / src ", ...

Como puedes ver, la Envato \ Aws \ espacio de nombres se asigna a la paquetes / envato / aws / src directorio. Ahora, solo necesitamos ejecutar el comando dump-autoload para regenerar las asignaciones del compositor.

$ compositor dump-autoload

Ahora, puedes usar el Envato \ Aws \ espacio de nombres en su aplicación y recogerá los archivos desde la ubicación correcta!

Archivo compositor del paquete

Ahora, vamos a seguir adelante y agregar un paquete específico compositor.json archivo para que pueda distribuir su paquete al repositorio de packagist.

Ve a la paquetes / envato / aws directorio y ejecute el siguiente comando para generar una compositor.json archivo para su paquete.

$ compositor init

Se te indicarán las preguntas habituales, así que solo repásalo y creará un compositor.json expediente.

Por lo menos, debería verse algo como esto..

"name": "envato / aws", "description": "Ejemplo de carga de archivos a AWS S3 Cloud", "estabilidad mínima": "dev", "require":

Ruta

En nuestro paquete, crearemos una página simple que muestra el estado del archivo cargado. Así que necesitamos crear una ruta asociada a esa página..

Vamos a crear un archivo de ruta en paquetes / envato / aws / src / route / web.php.

¿Requiere alguna explicación? El siguiente paso obvio es crear el archivo de controlador asociado.

Controlador

Vamos a crear un archivo controlador en packages / envato / aws / src / Controllers / AwsController.php con los siguientes contenidos.

disco ('s3'); // cargar el almacenamiento local $ localStorage = $ storage-> disk ('local'); // ruta predeterminada del almacenamiento local "storage / app" $ sourceFileContents = $ localStorage-> get ('test.jpg'); // ruta de acceso al destino en la nube S3 $ destFilePath = 'test_new.jpg'; // init vars $ imageUrl = "; $ errorMsg ="; // subir el archivo a AWS S3 si ($ awsS3Storage-> put ($ destFilePath, $ sourceFileContents, 'public')) $ imageUrl = env ('AWS_CDN_URL'). env ('AWS_BUCKET'). '/'. $ destFilePath;  else $ errorMsg = '¡Ups! Algo salió mal :( '; // vista de retorno de vista de llamada (' aws :: upload ', [' imageUrl '=> $ imageUrl,' errorMsg '=> $ errorMsg]);

Revisemos el archivo para comprender para qué está destinado cada fragmento de código..

Iniciamos las cosas estableciendo un espacio de nombres de nuestro controlador en espacio de nombres Envato \ Aws \ Controladores. Recordemos que agregamos el mapeo de Envato \ Aws a paquetes / envato / aws / src en la raíz compositor.json archivo para que pueda encontrar nuestros archivos paquete.

A continuación, hemos definido la subir Método que hace necesario sincronizar archivos locales con la nube de Amazon S3. Lo importante a tener en cuenta aquí es el primer argumento del método de carga que solicita la \ Illuminate \ Contracts \ Filesystem \ Factory dependencia. Durante la ejecución, se inyectará el correspondiente contrato de Laravel..

Ahora, podríamos usar la instancia de fábrica del sistema de archivos para crear instancias de disco según sea necesario. La instancia de disco en Laravel es el controlador que le permite acceder fácilmente a los sistemas de archivos subyacentes, como el disco local, la nube de Amazon S3, etc..

// cargar s3 storage $ awsS3Storage = $ storage-> disk ('s3'); // cargar el almacenamiento local $ localStorage = $ storage-> disk ('local');

Para simplificar, transferiremos el archivo de imagen estática que ya está disponible en el almacenamiento local predeterminado de Laravel, y la ruta es almacenamiento / app / test.jpg.

Como primer paso, tomemos el contenido del archivo fuente..

// ruta predeterminada del almacenamiento local "storage / app" $ sourceFileContents = $ localStorage-> get ('test.jpg');

Con todo configurado como se mencionó, debería poder sincronizar un archivo con Amazon S3 usando el método put.

// subir el archivo a AWS S3 si ($ awsS3Storage-> put ($ destFilePath, $ sourceFileContents, 'public')) $ imageUrl = env ('AWS_CDN_URL'). env ('AWS_BUCKET'). '/'. $ destFilePath;  else $ errorMsg = '¡Ups! Algo salió mal :(';

Asegúrese de haber configurado las variables de entorno de AWS correctamente, en caso de que algo no funcione como se esperaba.

Y lo último es llamar a un archivo de vista que muestra la imagen sincronizada y un mensaje apropiado.

// vista de retorno de vista de llamada ('aws :: upload', ['imageUrl' => $ imageUrl, 'errorMsg' => $ errorMsg]);

Por supuesto, aún no hemos creado un archivo de vista, y de eso se trata exactamente la siguiente sección.

Ver

Vamos a crear un archivo de vista en paquetes / envato / aws / src / views / upload.blade.php con los siguientes contenidos.

      Laravel        @if (Route :: has ('login'))  @if (Auth :: check ()) Inicio @else Iniciar sesión Registrarse @endif 
 @terminara si   Carga de archivos a S3 Cloud 
  @if ($ imageUrl)  @más $ errorMsg @terminara si

Es un archivo de vista bastante estándar que muestra la imagen cargada tras la carga exitosa, o un mensaje de error apropiado..

Proveedor de servicio

Casi hemos terminado con nuestro paquete, ya que hemos creado los archivos necesarios. El siguiente paso es crear un proveedor de servicios para que podamos registrar las rutas y las vistas de nuestro paquete..

Vamos a crear un archivo de proveedor de servicios en paquetes / envato / aws / src / Providers / AwsServiceProvider.php con los siguientes contenidos.

loadRoutesFrom (__ DIR __. '/… /routes/web.php'); // carga los archivos de vista $ this-> loadViewsFrom (__ DIR __. '/… / views', 'aws'); // publicar archivos $ this-> publica ([__DIR __. '/… / views' => resource_path ('views / vendor / aws'),]);  / ** * Registrar los servicios de la aplicación. * * @return void * / public function register ()

Obviamente, podría haber creado el archivo del proveedor de servicios utilizando también el comando artisan. Pero habría requerido un paso adicional para mover el archivo de aplicación / Proveedores a nuestro paquete.

De todos modos, veamos el archivo del proveedor de servicios que se acaba de crear..

En primer lugar, cargamos las rutas y vistas asociadas con nuestro paquete..

// cargar rutas $ this-> loadRoutesFrom (__ DIR __. '/… /routes/web.php'); // carga los archivos de vista $ this-> loadViewsFrom (__ DIR __. '/… / views', 'aws');

A continuación, proporcionamos el soporte para publicar las vistas de nuestros paquetes para que los desarrolladores que quieran anular las vistas puedan hacerlo. La próxima vez que corran el vendedor artesanal php: publicar comando, Laravel copia las vistas desde paquetes / envato / aws / src / views / a recursos / vistas / proveedor / aws.

Ahora, pueden cambiar las vistas bajo el recursos / vistas / proveedor / aws directorio, y Laravel lo recogerá automáticamente en lugar de las vistas en paquetes / envato / aws / src / views /. De hecho, es la forma correcta de modificar las vistas de paquetes de terceros, en lugar de modificar directamente las vistas de paquetes.

Eso es todo en lo que se refiere al proveedor de servicios. Como era de esperar, debemos agregar la entrada del proveedor de servicios en config / app.php. Agregue la siguiente entrada en el proveedores formación.

… / * * Proveedores de servicios de aplicaciones… * / App \ Providers \ AppServiceProvider :: class, App \ Providers \ AuthServiceProvider :: class, App \ Providers \ BroadcastServiceProvider :: class, App \ Providers \ EventServiceProvider :: class, App \ Providers \ RouteServiceProvider :: class, Envato \ Aws \ Providers \ AwsServiceProvider :: class, // Nuestro proveedor de servicios de paquetes ...

Y aquí está, todo está en orden ahora, para que podamos seguir adelante y probar nuestro paquete..

Continúe y ejecute la URL http: // your-laravel-application / aws / s3 / upload en su navegador. Si todo va bien, debería ver la imagen en su página que se carga desde la nube de Amazon S3. Por favor, avíseme si tiene algún problema, y yo estaría más que feliz de responder a esos.

Así que estamos en la nota final de este artículo, y espero que lo hayan disfrutado.!

Conclusión

Hoy, discutimos una de las características importantes de la administración de paquetes de marco de Laravel. En el proceso de configuración de nuestro paquete Laravel personalizado, pasamos por un ejemplo del mundo real que demuestra cómo se puede cargar una imagen en la nube de Amazon S3..

Es una característica realmente interesante si desea agrupar y distribuir un conjunto de funcionalidades en conjunto. De hecho, podría considerar esto como una opción para abordar el desarrollo de su módulo personalizado en Laravel.

Para aquellos de ustedes que ya están comenzando con Laravel o que desean ampliar sus conocimientos, sitio o aplicación con extensiones, tenemos una variedad de cosas que puede estudiar en Envato Market..

Como siempre, puede dejar sus valiosos comentarios y comentarios en el feed a continuación.!

Código