First, follow the instructions in the section Chapter 16, Installing on Cloud Foundry to deploy the Skipper Server to Cloud Foundry.
When you start the Skipper shell, by default it tries to look for the Skipper server on the same (local) machine.
To specify the Skipper server that is running on Cloud Foundry, provide the serverUrl when launching the shell or use the config command after the shell has started.
java -jar spring-cloud-skipper-shell-1.0.0.RC2.jar --spring.cloud.skipper.client.serverUri=https://mlp-skipper.cfapps.io/api
or
skipper:>skipper config --uri https://mlp-skipper.cfapps.io/api Successfully targeted https://mlp-skipper.cfapps.io/api
The repo list command shows the experimental and local repositories, since they are configured by default.
The local repository is where you can upload new packages.
The experimental repository has a few "hello world" applications to help get you started.
skipper:>repo list ╔════════════╤═══════════════════════════════════════════════════════════╤═════╤═════╗ ║ Name │ URL │Local│Order║ ╠════════════╪═══════════════════════════════════════════════════════════╪═════╪═════╣ ║experimental│http://skipper-repository.cfapps.io/repository/experimental│false│0 ║ ║local │http://d4d6d1b6-c7e5-4226-69ec-01d4:7577 │true │1 ║ ╚════════════╧═══════════════════════════════════════════════════════════╧═════╧═════╝
and the package search command shows
skipper:>package search ╔═════════════════╤═══════╤════════════════════════════════════════════════════════════════════════════════╗ ║ Name │Version│ Description ║ ╠═════════════════╪═══════╪════════════════════════════════════════════════════════════════════════════════╣ ║helloworld │1.0.1 │The app has two endpoints, /about and /greeting in Portuguese. Maven resource. ║ ║helloworld │1.0.0 │The app has two endpoints, /about and /greeting in English. Maven resource. ║ ║helloworld-docker│1.0.1 │The app has two endpoints, /about and /greeting in Portuguese. Docker resource.║ ║helloworld-docker│1.0.0 │The app has two endpoints, /about and /greeting in English. Docker resource. ║ ╚═════════════════╧═══════╧════════════════════════════════════════════════════════════════════════════════╝
The command platform list shows which platforms the server has been configured with, in this case just one Cloud Foundry platform.
Disabling the local platform during the installation process via property enableLocalPlatform = false is why the default local platform does not appear.
╔════╤════════════╤═════════════════════════════════════════════════════════════════════════╗ ║Name│ Type │ Description ║ ╠════╪════════════╪═════════════════════════════════════════════════════════════════════════╣ ║pws │cloudfoundry│org = [scdf-ci], space = [space-mark], url = [https://api.run.pivotal.io]║ ╚════╧════════════╧═════════════════════════════════════════════════════════════════════════╝
Let’s install the Hello World app, specifically, the maven based artifact.
skipper:>package install --release-name helloworldpcf --package-name helloworld --package-version 1.0.0 --platform-name pws --properties spec.deploymentProperties.spring.cloud.deployer.cloudfoundry.route=helloworldpcf.cfapps.io Released helloworldpcf. Now at version v1.
The deployment property spring.cloud.deployer.cloudfoundry.route=helloworldpcf.cfapps.io is set so that when different versions of this application are deployed, they have the same http route.
The command option --platform-name pws was specified since the default value of that shell option is default.
You can register a platform under the name default when installing Skipper, but it is a best practice to specify the target platform name.
Monitor the progress of the deployment using the release status command.
skipper:>release status --release-name helloworldpcf ╔═══════════════╤════════════════════════════════════════════════╗ ║Last Deployed │Thu Jan 18 13:18:44 EST 2018 ║ ║Status │DEPLOYED ║ ║Platform Status│The applications are being deployed. ║ ║ │[helloworldpcf-helloworld-v1], State = [partial]║ ╚═══════════════╧════════════════════════════════════════════════╝
Eventually the Platform Status will say All applications have been successfully deployed.
![[Note]](images/note.png) | Note |
|---|---|
The status |
A cf apps command will now have a new listing for this deployed application.
$ cf apps Getting apps in org scdf-ci / space space-mark as [email protected]... OK name requested state instances memory disk urls helloworldpcf-helloworld-v1 started 1/1 1G 1G helloworldpcf.cfapps.io
You can now curl the greeting endpoint and the about endpoint.
$ curl http://helloworldpcf.cfapps.io/greeting
Hello World!
$ curl http://helloworldpcf.cfapps.io/about
Hello World v1.0.0.RELEASEThe name of the application is based on the convention <release-name>-<package-name>-v<incrementing-counter>.
Also note that we specified a route for this application that is different than the application’s name.
The deployment property spring.cloud.deployer.cloudfoundry.route is set to something that will not change across the deployment of different versions of this application, in this case helloworldpcf.cfapps.io.
The package provides a means to template the application version, application properties and deployment properties that are used to deploy the application to Cloud Foundry.
The manifest get command shows the final YAML file which is passed off to the Spring Cloud Deployer Library.
skipper:>manifest get --release-name helloworldpcf --- # Source: helloworld.yml apiVersion: skipper.spring.io/v1 kind: SpringCloudDeployerApplication metadata: name: helloworld type: demo spec: resource: maven://org.springframework.cloud.samples:spring-cloud-skipper-samples-helloworld:1.0.0.RELEASE applicationProperties: deploymentProperties: spring.cloud.deployer.cloudfoundry.route: helloworldpcf.cfapps.io
The manifest is in a Kubernetes Resource file inspired format. By looking at the manifest you can see which maven artifact was used and which properties were set before the final push to Cloud Foundry. The metadata values that are present will be used in a future release to support searching for releases based on those values.
Since it is somewhat awkward to specify multiple flattened out YAML values for the --properties argument in the shell, you can also specify the location of a YAML file when installing or upgrading.
We will use a YAML file, named helloworld-upgrade.yml to update the release.
This application contains a Spring Boot @ConfigurationProperty named helloworld.greeting, so we will set that along with a standard Spring Boot property endpoints.sensitive=false.
We will also bump the memory up to 2G from the default 1G.
The contents of the helloworld-upgrade.yml file is shown below.
spec:
applicationProperties:
endpoints.sensitive: false
helloworld.greeting: yo
deploymentProperties:
spring.cloud.deployer.cloudfoundry.route: helloworldpcf.cfapps.io
spring.cloud.deployer.memory: 2048mRun the release upgrade command
skipper:>release upgrade --release-name helloworldpcf --package-name helloworld --package-version 1.0.0 --file /home/mpollack/helloworld-upgrade.yml helloworldpcf has been upgraded. Now at version v2.
This will start another instance of the hello world application and Skipper will determine when it can stop the instance of the previous instance.
If you do not specify --package-version it will pick the latest version of the helloworld package.
You do not need to specify the --platform-name as it will always be where the current application was deployed.
The cf apps and cf routes command shows
$ cf apps Getting apps in org scdf-ci / space space-mark as [email protected]... OK name requested state instances memory disk urls helloworldpcf-helloworld-v1 started 1/1 1G 1G helloworldpcf.cfapps.io helloworldpcf-helloworld-v2 stopped 0/1 2G 1G helloworldpcf.cfapps.io
and
$ cf routes Getting routes for org scdf-ci / space space-mark as [email protected] ... space host domain port path type apps service space-mark helloworldpcf cfapps.io helloworldpcf-helloworld-v1,helloworldpcf-helloworld-v2
At this point Skipper is checking the health of the new application.
The default health check is to test that the HTTP port of the application is open.
There is a simple customization in Skipper to influences the way the health check is performed.
The property spring.cloud.skipper.server.strategies.healthcheck.timeoutInMillis is the maximum time the upgrade process will wait for a healthy app.
The default value is 5 minutes.
Skipper will fail the deployment if it is not healthy within that time.
The property spring.cloud.skipper.server.strategies.healthcheck.sleepInMillis is how long to sleep between health checks.
The current upgrade strategy is very simple, if the new app is healthy, the old app is removed. There is not a rolling upgrade option, all new apps are deployed, checked for health, and then previous versions removed. More flexible upgrade strategies are planned in a future release.
You can now curl the greeting endpoint and the about endpoint.
$ curl http://helloworldpcf.cfapps.io/greeting
yo
$ curl http://helloworldpcf.cfapps.io/about
Hello World v1.0.0.RELEASEThe release list command shows you the current DEPLOYED and DELETED releases for every release name.
In this case there is just one entry
╔═════════════╤═══════╤══════════════════╤════════╤═══════════╤═══════════╤══════════╤════════════════════════════════════════╗ ║ Name │Version│ Last updated │ Status │ Package │ Package │ Platform │ Platform Status ║ ║ │ │ │ │ Name │ Version │ Name │ ║ ╠═════════════╪═══════╪══════════════════╪════════╪═══════════╪═══════════╪══════════╪════════════════════════════════════════╣ ║helloworldpcf│2 │Thu Jan 18 │DEPLOYED│helloworld │1.0.0 │pws │[helloworldpcf-helloworld-v2], State = ║ ║ │ │13:26:50 EST 2018 │ │ │ │ │[helloworldpcf-helloworld-v2-0=deployed]║ ╚═════════════╧═══════╧══════════════════╧════════╧═══════════╧═══════════╧══════════╧════════════════════════════════════════╝
You can get the full history of the release using the release history command
skipper:>release history --release-name helloworldpcf ╔═══════╤════════════════════════════╤════════╤════════════╤═══════════════╤════════════════╗ ║Version│ Last updated │ Status │Package Name│Package Version│ Description ║ ╠═══════╪════════════════════════════╪════════╪════════════╪═══════════════╪════════════════╣ ║2 │Thu Jan 18 13:26:50 EST 2018│DEPLOYED│helloworld │1.0.0 │Upgrade complete║ ║1 │Thu Jan 18 13:18:44 EST 2018│DELETED │helloworld │1.0.0 │Delete complete ║ ╚═══════╧════════════════════════════╧════════╧════════════╧═══════════════╧════════════════╝
A more typical upgrade process is not to change application properties, but to change the version of the application because the code has changed. We will now upgrade the release to use a new maven artifact, version 1.0.1, which also corresponds to version 1.0.1 of the helloworld skipper package. In this case, we will not add any additional properties other than the route.
skipper:>release upgrade --release-name helloworldpcf --package-name helloworld --package-version 1.0.1 --properties spec.deploymentProperties.spring.cloud.deployer.cloudfoundry.route=helloworldpcf.cfapps.io helloworldpcf has been upgraded. Now at version v3.
Note that the current release’s property values such as using 2G, or the greeting being yo are not carried over.
In a future release we will introduce a --reuse-properties command that will carry the current release properties over to the next release to be made.
You can monitor the status of the upgrade using the status command
skipper:>release status --release-name helloworldpcf ╔═══════════════╤════════════════════════════════════════════════╗ ║Last Deployed │Thu Jan 18 13:49:42 EST 2018 ║ ║Status │UNKNOWN ║ ║Platform Status│The applications are being deployed. ║ ║ │[helloworldpcf-helloworld-v3], State = [partial]║ ╚═══════════════╧════════════════════════════════════════════════╝
And a curl command shows
curl http://helloworldpcf.cfapps.io/greeting
Olá Mundo!
$ curl http://helloworldpcf.cfapps.io/about
Hello World v1.0.1.RELEASEOur release history now looks like
skipper:>release history --release-name helloworldpcf ╔═══════╤════════════════════════════╤════════╤════════════╤═══════════════╤════════════════╗ ║Version│ Last updated │ Status │Package Name│Package Version│ Description ║ ╠═══════╪════════════════════════════╪════════╪════════════╪═══════════════╪════════════════╣ ║3 │Thu Jan 18 13:49:42 EST 2018│DEPLOYED│helloworld │1.0.1 │Upgrade complete║ ║2 │Thu Jan 18 13:26:50 EST 2018│DELETED │helloworld │1.0.0 │Delete complete ║ ║1 │Thu Jan 18 13:18:44 EST 2018│DELETED │helloworld │1.0.0 │Delete complete ║ ╚═══════╧════════════════════════════╧════════╧════════════╧═══════════════╧════════════════╝
Next we will use the rollback command to deploy an older version of the application.
Since we have the manifest for that version, we have all we need to redeploy an earlier release.
skipper:>release rollback --release-name helloworldpcf --release-version 2
helloworldpcf has been rolled back. Now at version v4.The history now shows a new v4 version, even though it is identical in terms of app behavior to the v2 version.
skipper:>release history --release-name helloworldpcf ╔═══════╤════════════════════════════╤════════╤════════════╤═══════════════╤════════════════╗ ║Version│ Last updated │ Status │Package Name│Package Version│ Description ║ ╠═══════╪════════════════════════════╪════════╪════════════╪═══════════════╪════════════════╣ ║4 │Thu Jan 18 13:51:43 EST 2018│DEPLOYED│helloworld │1.0.0 │Upgrade complete║ ║3 │Thu Jan 18 13:49:42 EST 2018│DELETED │helloworld │1.0.1 │Delete complete ║ ║2 │Thu Jan 18 13:26:50 EST 2018│DELETED │helloworld │1.0.0 │Delete complete ║ ║1 │Thu Jan 18 13:18:44 EST 2018│DELETED │helloworld │1.0.0 │Delete complete ║ ╚═══════╧════════════════════════════╧════════╧════════════╧═══════════════╧════════════════╝
The curl commands show
$ curl http://helloworldpcf.cfapps.io/greeting
yo
$ curl http://helloworldpcf.cfapps.io/about
Hello World v1.0.0.RELEASE