https://media.notthebee.com/articles/6176ef656e4306176ef656e431.jpg
This is great:
Not the Bee
Just another WordPress site
https://media.notthebee.com/articles/6176ef656e4306176ef656e431.jpg
This is great:
Not the Bee
https://opengraph.githubassets.com/d5515559507e3719b5e34e334c25d68142fec164e7e542a28166483fd39bd919/ash-jc-allen/short-url/releases/tag/v6.0.0
You can’t perform that action at this time.
Laravel News Links
https://avatars.githubusercontent.com/u/92824325?s=280&v=4
Laravel News Links
https://production.ams3.digitaloceanspaces.com/2021/08/Social-Sharing-photo-Template-1-13.png
AWS Lambda brought the term “serverless” into reality and shook the world of software development.
It gained a lot of popularity in the last few years and is one of the fastest-growing technologies provided by Amazon. One of its strengths is the ability to pay only for the amount of time it takes to run the code and pay nothing while the code isn’t running.
To accomplish this business model, AWS made Lambda scalable by default. You only provide the amount of memory your process needs and the cloud provider will be responsible for provisioning as much hardware as necessary every time your source code needs to be executed.
I have been working with AWS for 4 years and AWS Lambda in particular for 2 years. In this post, I want to share hands-on experience on deploying a Laravel API service on AWS Lambda.
To follow along, you’ll need a few ingredients:
– AWS Account
– IAM Access Key / Secret Key
– PHP
– [Composer](https://getcomposer.org/download/)
– [NPM](https://nodejs.org/en/download/)
– [Serverless](https://goserverless.com)
– [Bref](https://bref.sh)
– [Laravel](https://laravel.com)
– [Optional] Docker
If you have an AWS Account already, everything else is manageable.
Let’s get started!
Let’s first start by generating programmatic access to AWS. We’ll need it so that we can provide the Serverless Framework with the ability to provision/deploy AWS lambda into our AWS account.
Log into your AWS account and go to IAM → Users → Add User. Choose a username for your account, check the Programmatic Access checkbox, and hit Next: Permission.
Under Attach existing policies directly, select the AdministratorAccess policy. We can now proceed to Next: Tags and subsequently Next: Review (Tags are optional).
Take this opportunity to double-check the configuration. Once you click Create User, AWS will show you the Access Key and Secret Key. The Secret Key is unrecoverable, so make sure to save it.
If you have these tools installed in your environment, you may skip this step. Otherwise, I’ll show you how I install these tools inside a docker container.
#!/usr/bin/env sh
docker run --rm -v $(pwd):/app -w /app -it alpine:3.14 sh
apk add php8 php8-phar php8-curl php8-openssl php8-dom php8-xml php8-xmlwriter php8-xmlreader php8-tokenizer php8-mbstring php8-fileinfo php8-simplexml
apk add composer npm
cp /usr/bin/php8 /usr/bin/php
npm install -g serverless
This sequence of commands will start an Alpine Linux container and install PHP 8, Composer, NPM, and Serverless. Keep this container open because we’ll continue using it for the next steps.
Let’s start a new Laravel project and install Bref using Composer.
#!/usr/bin/env sh
composer create-project laravel/laravel my-api
cd my-api
composer require bref/bref
./vendor/bin/bref init
0
rm index.php
The 0 above is to automatically select the option [0] Web application. Bref will then create serverless.yml and index.php. Since we’re using Laravel, we can remove the index.php and just keep the serverless.yml.
Before we move on to Serverless, let’s add a sample routing for our API by editing the routes/api.php file.
<?php
Route::get('/hello', fn () => response(['data' => 'Hello from Laravel!']));
Remember that by default the api.php folder is configured with the /api prefix, so our route will actually be /api/hello.
Before we dive into the serverless.yml template, let’s configure the Serverless Framework. We can do that in two ways:
export AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY_HERE
export AWS_SECRET_ACCESS_KEY=YUR_SECRET_KEY_HERE
The framework will automatically pick up the credentials from the environment variable and perform deployments into your account.
The 2nd approach is to use serverless config credentials:
serverless config credentials --provider aws --key YOUR_ACCESS_KEY_HERE --secret YOUR_SECRET_KEY_HERE
After configuring the credentials for your AWS account, let’s tweak the serverless.yml template generated by Bref:
service: app
provider:
name: aws
region: us-east-1
runtime: provided.al2
plugins:
- ./vendor/bref/bref
functions:
api:
handler: public/index.php
environment:
LOG_CHANNEL: stderr
SESSION_DRIVER: array
CACHE_DRIVER: array
description: ''
timeout: 28 # in seconds (API Gateway has a timeout of 29 seconds)
layers:
- ${bref:layer.php-80-fpm}
events:
- httpApi: '*'
# Exclude files from deployment
package:
patterns:
- '!node_modules/**'
- '!tests/**'
We change the handler from index.php to public/index.php as that’s the entry point for a Laravel application. There are also 3 important environment variables: LOG_CHANNEL, SESSION_DRIVER, and CACHE_DRIVER. The stderr driver will automatically drive log messages into CloudWatch and the array driver will essentially disable Session and Cache.
To deploy the project, let’s issue the following command:
sls deploy
The output should look like this:
/app/my-api # sls deploy
Serverless: Deprecation warning: Detected ".env" files. In the next major release variables from ".env" files will be automatically loaded into the serverless build process. Set "useDotenv: true" to adopt that behavior now.
More Info: https://www.serverless.com/framework/docs/deprecations/#LOAD_VARIABLES_FROM_ENV_FILES
Serverless: Deprecation warning: Resolution of lambda version hashes was improved with better algorithm, which will be used in next major release.
Switch to it now by setting "provider.lambdaHashingVersion" to "20201221"
More Info: https://www.serverless.com/framework/docs/deprecations/#LAMBDA_HASHING_VERSION_V2
Serverless: Packaging service...
Serverless: Excluding development dependencies...
Serverless: Service files not changed. Skipping deployment...
Service Information
service: app
stage: dev
region: us-east-1
stack: app-dev
resources: 11
api keys:
None
endpoints:
ANY - https://0000000000.execute-api.us-east-1.amazonaws.com
functions:
api: app-dev-api
layers:
None
You can use your endpoint to test the API. It should look like this:
https://your_api_gateway_id.execute-api.us-east-1.amazonaws.com/api/hello
This is pretty much it! Your source code is now available behind API Gateway and Lambda and you’ll only pay for the time it takes for your code to execute.
If we try to load an invalid route, say https://your_api_gateway_id.execute-api.us-east-1.amazonaws.com/whatever, we’ll get a fatal error because Laravel will try to write the compiled php files for Blade. We can fix that by adjusting the VIEW_COMPILED_PATH environment variable. But since the focus is to deploy API-based projects, we can also add a nice little middleware to enforce that every HTTP Response will be JSON.
<?php
namespace App\Http\Middleware;
use Closure;
class EnforceJsonResponse
{
public function handle($request, Closure $next)
{
$request->headers->set('Accept', 'application/json');
return $next($request);
}
}
Then we can register it inside Kernel.php.
This introduction to Serverless with Laravel gives an overview of the foundation behind treating AWS Lambda as a hosting provider that only charges for execution time.
Although it is important to consider the aspect of running code on a read-only environment (with limited disk space under /tmp) and how two requests may not share the same live “container”, this approach doesn’t have a strong impact on the development practices and day-to-day operation of developers.
Providing APIs behind AWS Lambda makes them highly scalable and cheap if you have little to no usage at night or weekends, for instance.
Laravel News Links
https://assets.amuniversal.com/b557a1e0fa1b0139793a005056a9545d
Thank you for voting.
Hmm. Something went wrong. We will take a look as soon as we can.
Dilbert Daily Strip
https://i.ytimg.com/vi/0YDRQbgHBO8/maxresdefault.jpgInterface Dependency Injection – Add Interface Support To DI Container – Full PHP 8 TutorialLaravel News Links
https://i.ytimg.com/vi/ww_oVrL9ohA/maxresdefault.jpgIn this video, we will be looking at how to deploy a Laravel application on a dedicated server. Here we will create a digital ocean droplet and deploy our Laravel project there.Laravel News Links
http://img.youtube.com/vi/6jQixGjQIB0/0.jpgDid you know how easy it is to set up Github Actions with automated tests running on every PR? Let me show you.Laravel News Links
ADMIN UUMV
PSA – If you are ever lost while hiking, get stranded with a broken down car, etc and you notice your cell phone is either low on juice or has no signal, here is a tip that very well may save your life.Change the voicemail on your phone to a message that gives your approximate location, the time, the date, your situation (lost, out of gas, car broken down, injured, etc) and any special instructions such as you are staying with the car, you are walking toward a town, etc…. The best part of this is that even if your cell phone dies or stops working, voicemail still works, so anyone calling your phone looking for you will hear the message and know where to find you or where to send help.
https://content.artofmanliness.com/uploads/2021/10/Campfire-Lays-1.jpg
Every man should know how to build a fire. But every outdoor situation requires different types of campfire lays (set-ups in the firewood), so it’s imperative to know how to make more than one kind.
Here we highlight six of the most common and useful fire lays.
There’s a reason this is the go-to campfire lay for most outdoorsmen: it’s very easy to get a fire going with a teepee lay. It’s also a great fire for cooking and warmth. The one downside of a teepee fire lay is that it burns quickly, requiring a lot of fuel to keep it going.
Many other fire lays rely on a teepee lay to initially get going, so it’s a vital lay to master.
How to make: Place your tinder bundle on the ground. Above your tinder bundle, use kindling to build a small teepee. Start with small twigs and build up to large sticks. Leave an opening in your teepee on the side the wind is blowing against. This will ensure that your fire gets the air it needs for effective combustion. Light your tinder bundle. As the fire gets going, add increasingly thick sticks, and eventually large fuel logs, in the same teepee shape.
If you’ve watched old Western movies, you’ve likely seen a star fire lay. It’s the fire lay of choice for cowboys ranging in areas where there isn’t much wood. The star fire lay doesn’t make a very big or hot fire, but it’s economical in terms of fuel and easy to set up.
How to make: Lay five or six logs on the ground like the spokes of a wheel. The arrangement will look like a star. Inside the hub of your wheel/star, start a small fire with a teepee lay. As the main logs of the star lay burn, push them towards the center.
The lean-to fire lay creates a protective canopy under which you can place your tinder bundle. As such, it’s a good fire lay to use in windy or rainy conditions. The trade-off is that this set-up does restrict airflow a little, so it can sometimes make getting a fire going a bit harder.
How to make: Place your tinder against a large log. Lean small twigs and sticks against the log and above your tinder pile. Now you see why it’s called a “lean-to.” Light your tinder bundle.
One glance at its structure and it’s easy to see how the log cabin lay got its name. You’re going to build a small log cabin with fuel logs around a small teepee fire lay. The resulting fire burns big and hot and doesn’t require as much tending once you light it, as the flames start burning the big logs which form the log cabin shape.
How to make: Start off by building a small teepee fire lay. Get large pieces of fuel wood and place them on opposite sides of the teepee. Lay other pieces of wood across the first set of fuel wood, parallel on the other sides of the teepee. Think of the way you build with Lincoln Logs. Build your log cabin until it’s the same height as your teepee, more or less. Light the teepee on fire.
The structure of the parallel/long lay funnels air into the fire, creating a hotter burn, which can come in handy for cooking. Because the structure blocks the wind from the sides, it can also be a good fire lay for windy conditions.
How to make: Place two large long green logs parallel to each other about six inches apart. Start a small teepee fire in between the logs. You can also dig a long trench in the ground and start a fire inside the trench. Rest pots and pans across the logs or trench to create a makeshift cooking range.
The ultimate “set it and forget it” fire lay, this campfire will last for hours without tending. While it does take more work to set it up and get it going, if you need a fire that will keep you warm through the night, without you having to frequently arise to fuel it, this is the lay for you.
How to make: Stack your fuel logs in a pyramid shape, each layer perpendicular to the next. Start with the largest logs on the bottom. With each new layer, use smaller pieces of wood. Position logs so there’s minimal spacing between them. On top of your pyramid, place your tinder and build a small teepee fire. Light your tinder bundle. As each layer of the pyramid burns, it sinks and falls, igniting the layer below it. The fire feeds itself.
The post The 6 Fire Lays Every Man Should Know appeared first on The Art of Manliness.
The Art of Manliness