Visualizzazione post con etichetta VCF. Mostra tutti i post
Visualizzazione post con etichetta VCF. Mostra tutti i post

martedì 7 aprile 2026

[VCF 9.0] Configure Single Sign-On in embedded mode

VCF Single Sign-On


In a previous post we went through the steps on how to configure an LDAP directory to be used as a Identity Source in VCF 9.0.

Today we’re going to be going through the steps of configuring SSO, using the previous configuration as identity source.

When you configure VCF Single Sign-On you can either implement it in embedded mode within the management domain vCenter or deploy it in appliance mode.

Use the embedded deployment mode if you want to use VCF Identity Broker that is embedded in the management domain vCenter and do not want to deploy a VCF Identity Broker appliance for VCF Single Sign-On configuration. You use the embedded deployment mode typically within a single VCF Instance. In the embedded deployment mode, the VCF Identity Broker is configured in the management domain vCenter of the VCF Instance. Embedded Deployment Mode The following diagram shows the embedded deployment mode where the VCF Identity Broker is configured in the management domain vCenter.
Further informations on which Identity Broker to configure are available on the official Broadcom website at this link.

Let's see how to set up the Identity Broker (embedded), below...

First, log into VCF Operations and browse to Fleet Management (1) > Identity & Access (2)...
...so if it's your first time, scroll down and accept all the Prerequisites checks (3) and CONTINUE(4)
Select a VCF instance, in my case "instance-a" (6)
We begin with step 1 by choosing the deployment mode by pressing START (7).
Check Identity broker (embedded) (8) and then NEXT (9)...
... EDIT (10) ...
... in my case as directory-base identity provider we choose Open LDAP (11) and hit NEXT (12).
In step 2, we CONFIGURE (13) now the identity provider.
At this stage, we need to configure Identity Broker to integrate with the identity provider selected for user authentication. As our identity provider, in our case, we'll use the one configured in the previous post.

We fill it in as follows (14):

Directory name: vcf-lab
Primary domain controller: ldap://192.168.1.246       389
Directory search attribute: Custom Attribute
Custom directory search attribute for Users: cn
Custom directory search attribute for Groups: cn
Base DN: dc=vcf,dc=lab
Bind user name: cn=admin,dc=vcf,dc=lab
Bind user password: VMware123!VMware123!

NEXT (15)
Leave LDAP Configuration (16) as default (shown in the picture) and press NEXT (17)...
... review and FINISH (18).
Step 3, to CONFIGURE (19) user and group provisioning
Review Directory Information, hit NEXT (20).
Leave the "Attribute Mappings" as default (shown in the picture) and press NEXT (21).
We should now search for group names and select the LDAP Directory group Distinguished Names (DNs) that we want to sync.

Specify the base group DN: ou=Groups,dc=vcf,dc=lab (22)

We click on "SELECT BASE GROUP DN" (23) button and we select the groups we would like so sync (in our case "Administrators" "Users" (24)) then NEXT (25).
Based on how our LDAP directory, we need to search the users we want to use...
We fill in the "Specify the base user DN" field with the following values: ou=Users,de=vcf,dc=lab (26) and we hit "SELECT BASE USER DN" (27) button.
We search for the user name we want to sync (28) (for instance "lorenzo", "admin.vcf" ecc. ) and then we select it (29).
When we are satisfied with the selected users we proceed by pressing NEXT (or SAVE) (30).
We review the identity provider configuration and, if it is correct, we confirm by pressing FINISH (31)...
... DONE (32) ...
... we finalize by pressing FINISH SETUP (33)...
... and confirming the end of the configuration with CONTINUE (34).
If the Identity Source has been configured correctly, you should see what's shown in the image below...
and in the Component Configuration section...
Everything seems to be properly configured, let's do a double check by connecting directly to vCenter.

We log in as administrator@vsphere.local and we click on the hamburger menu > Administration > Single Sign On> Configuration. We should see (as shown in the picture below) that VCF SSO is configured through the VCF Identity Broker.....
Under Administration > Single Sign On > Users and Groups ... we should see in Domain list the new Identity Source "vcf.lab".
For testing, we add the following users of the new "vcf.lab" domain with their respective roles:
User/Group: admin.vcf           Role: Administrator
User/Group: lorenzo               Role: Read-only
Let's test vCenter access using VCF SSO (38) login method; LOG IN (39).
we type the username "admin.vcf@vcf.lab" the password (in our case "VMware123!VMware123!") and hit LOG IN (41) button.
Bhoomm!! It works!!


That's it.

venerdì 3 aprile 2026

[VCF 9.0] Enable/Configure LDAP in HoloRouter to be used as Identity Source in VCF 9.0

Disclaimer:

The steps described below are fine for its own lab, but they do not meet the security criteria required for production deployment (e.g., lack of LDAPS/TLS by default and simplified RBAC, etc.).

As the title suggests, below I'll show you the steps to enable and configure LDAP as an Identity Source, leveraging the Kubernetes Cluster instance configured inside the HoloRouter appliance; which can then be used in your internal lab by the VCF 9.0 embedded identity broker.

We will then create an LDAP server instance on the Holorouter appliance, with the directory structure created as follows (the complete structure can be viewed and modified in the ldap-vcf.yaml file at the bottom of the page).

1. The Base DN

The root of our directory is dc=vcf,dc=lab. This is the entry point VCF will use to begin its search for identities.


2. Organizational Units (OUs)

We have segmented the directory into two logical containers to keep things clean:

  • ou=Users,dc=vcf,dc=lab: This is where all individual user accounts reside.
  • ou=Groups,dc=vcf,dc=lab: This contains the group definitions used for Role-Based Access Control (RBAC).

3. Users and Identities

The lab environment currently features four distinct users:

  • Administrative Accounts: admin and admin.vcf (used for management tasks).
  • Standard Users: lorenzo and test.

Note: All users utilize the inetOrgPerson object class, which is a standard requirement for most modern identity brokers.


4. Group Memberships

The directory uses the groupOfNames object class, which is the most common way to handle memberships in LDAP. We have defined two main groups:

  • cn=Administrators: Contains the two admin accounts. They can be associated with administrative roles in VCF 9.
  • cn=Users: Contains the standard lab users (lorenzo and test).

In VCF 9, use the following mapping based on our structure:

Field Value
Base DN dc=vcf,dc=lab
User Search Base ou=Users,dc=vcf,dc=lab
Group Search Base ou=Groups,dc=vcf,dc=lab
Common Name Identifier cn or uid
Group Member Attribute member


However, before creating the LDAP structure and expose it to the external port, we should create a persistent volume (as indicated in the ldap-pv.yaml file at the bottom of the page). This ensures that even if we upgrade the container image or restart the cluster/appliance, our lab users remain intact. In our case in holorouter, we'll create (if doesn't exist) and use a local directory "/opt/ldap-data".



Let's see the step-by-step procedure below:

1. Download the appliance, deploy, and run it.

First of all, download the HoloRouter appliance from this link, deploy it, and power it on. Detailed steps on how to distribute an OVA are beyond the scope here.

2. Log in and verify that the services have started correctly.

As a second step, once the appliance is turned on and running, we log in and verify the services by running the following commands:

kubectl get pods,service,deployment,configmap,pv -A
If everything is well, the PODs should be in STATUS running as shown in the image below.

3. Create/Copy .yaml files

Now let's create the manifest files needed to deploy the Kubernetes instances.
For convenience, I'll create the "vcf" directory (in /root/vcf), where I'll create the following files: ldap-pv.yaml (for creating the persistent volume) and ldap-vcf.yaml (for instantiating the LDAP service and populating it as indicated above).

root@holorouter [ ~ ]# mkdir -p ./vcf
root@holorouter [ ~ ]# cd vcf
root@holorouter [ ~/vcf ]# vi ldap-pv.yaml
Copy and paste the lines from the file "ldap-pv.yaml" at the bottom of the page and save the file Do the same for the file "ldap-vcf.yaml"
Note: The password used for all the users is "VMware123!VMware123!"

4. Create the Persistent Volume

To create and verify the creation of the persistent volume, we run the following commands in sequence:

root@holorouter [ ~/vcf ]# kubectl apply -f ldap-pv.yaml
....
root@holorouter [ ~/vcf ]# kubectl get pv -A 
As you can see from the image above, the PV has been successfully created, so let's proceed to the next step...

5. OpenLDAP Framework Deployment

One of the last steps is to create LDAP. We do this by running the following commands:

root@holorouter [ ~/vcf ]# kubectl apply -f ldap-vcf.yaml
....
root@holorouter [ ~/vcf ]# kubectl get pods -A 
If everything went as it should, the openldap POD status should be running ... Note: As a Kubernetes image for LDAP, "osixia/openldap" was used.

6. Tests

Let's check now that everything is working correctly (see image below)....

kubectl get pods,service,deployment,configmap,pv -A
...since everything seems to be working fine, let's try to make an ldap request testing a standard user ("lorenzo") login by running the following command ...
ldapwhoami -x -H ldap://10.106.209.20 -D "cn=lorenzo,ou=Users,dc=vcf,dc=lab" -w 'VMware123!VMware123!'
If the query was successful, it should show what is shown in the image above.
This time, let's run the same test, but from an external machine, using the holorouter's public IP ... We can use the following command to perform a complete discovery of the newly configured LDAP....
ldapsearch -x -H ldap://192.168.1.246 -D "cn=admin,dc=vcf,dc=lab" -w 'VMware123!VMware123!' -b "dc=vcf,dc=lab"

As a next step, we just need to see how to use/integrate the newly configured LDAP in VCF9. This will be described in a future post here.



Below is the yaml files ...

"ldap-pv.yaml"

apiVersion: v1
kind: PersistentVolume
metadata:
  name: ldap-data-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  hostPath:
    path: "/opt/ldap-data" # The data will be saved in this physical folder of the node
    type: DirectoryOrCreate # If the folder does not exist, it creates it automatically.


"ldap-vcf.yaml"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ldap-data-pvc
  labels:
    app: openldap
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: ldap-bootstrap-ldif
  labels:
    app: openldap
data:
  01-struttura.ldif: |-
    dn: ou=Users,dc=vcf,dc=lab
    objectClass: organizationalUnit
    ou: Users
    
    dn: ou=Groups,dc=vcf,dc=lab
    objectClass: organizationalUnit
    ou: Groups
    
    dn: cn=admin,ou=Users,dc=vcf,dc=lab
    objectClass: top
    objectClass: person
    objectClass: organizationalPerson
    objectClass: inetOrgPerson
    cn: admin
    sn: Administrator
    uid: admin
    userPassword: VMware123!VMware123!
    
    dn: cn=admin.vcf,ou=Users,dc=vcf,dc=lab
    objectClass: top
    objectClass: person
    objectClass: organizationalPerson
    objectClass: inetOrgPerson
    cn: admin.vcf
    sn: AdminVCF
    uid: admin.vcf
    userPassword: VMware123!VMware123!
    
    dn: cn=lorenzo,ou=Users,dc=vcf,dc=lab
    objectClass: top
    objectClass: person
    objectClass: organizationalPerson
    objectClass: inetOrgPerson
    cn: lorenzo
    sn: Lorenzo
    uid: lorenzo
    userPassword: VMware123!VMware123!
    
    dn: cn=test,ou=Users,dc=vcf,dc=lab
    objectClass: top
    objectClass: person
    objectClass: organizationalPerson
    objectClass: inetOrgPerson
    cn: test
    sn: TestUser
    uid: test
    userPassword: VMware123!VMware123!
    
    dn: cn=Administrators,ou=Groups,dc=vcf,dc=lab
    objectClass: top
    objectClass: groupOfNames
    cn: Administrators
    member: cn=admin,ou=Users,dc=vcf,dc=lab
    member: cn=admin.vcf,ou=Users,dc=vcf,dc=lab
    
    dn: cn=Users,ou=Groups,dc=vcf,dc=lab
    objectClass: top
    objectClass: groupOfNames
    cn: Users
    member: cn=lorenzo,ou=Users,dc=vcf,dc=lab
    member: cn=test,ou=Users,dc=vcf,dc=lab

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: openldap
  labels:
    app: openldap
spec:
  replicas: 1
  selector:
    matchLabels:
      app: openldap
  template:
    metadata:
      labels:
        app: openldap
    spec:
      containers:
      - name: openldap
        image: osixia/openldap:1.5.0
        ports:
        - containerPort: 389
          hostPort: 389 # <-- Directly exposes 389 on K8s node IP
          name: ldap
        env:
        - name: LDAP_ORGANISATION
          value: "VCF Lab"
        - name: LDAP_DOMAIN
          value: "vcf.lab"
        - name: LDAP_ADMIN_PASSWORD
          value: "VMware123!VMware123!"
        volumeMounts:
        # ConfigMap in sola lettura per l'iniezione iniziale
        - name: configmap-volume
          mountPath: /custom-ldif
        # Mount per la persistenza dei dati (Database)
        - name: ldap-data
          mountPath: /var/lib/ldap
          subPath: database
        # Mount per la persistenza della configurazione
        - name: ldap-data
          mountPath: /etc/ldap/slapd.d
          subPath: config
        
        lifecycle:
          postStart:
            exec:
              command:
              - /bin/sh
              - -c
              - |
                while ! ldapsearch -x -H ldap://localhost -D "cn=admin,dc=vcf,dc=lab" -w 'VMware123!VMware123!' -b "dc=vcf,dc=lab" > /dev/null 2>&1; do sleep 2; done;
                # Il comando fallirà silenziosamente se gli utenti esistono già nel PVC, grazie a "|| true"
                ldapadd -x -H ldap://localhost -D "cn=admin,dc=vcf,dc=lab" -w 'VMware123!VMware123!' -f /custom-ldif/01-struttura.ldif || true
                
      volumes:
      - name: configmap-volume
        configMap:
          name: ldap-bootstrap-ldif
      - name: ldap-data
        persistentVolumeClaim:
          claimName: ldap-data-pvc

---
apiVersion: v1
kind: Service
metadata:
  name: openldap-service
  labels:
    app: openldap
spec:
  type: ClusterIP
  ports:
  - port: 389
    targetPort: 389
    protocol: TCP
    name: ldap
  selector:
    app: openldap

That's it.

venerdì 20 marzo 2026

[SSPi] - Backup Process fail

Issue


The SSPI backup process fails and displays the following error message: “Management cluster backup failed. Please check logs for more details.” as shown below ..
management cluster backup failed, please check logs for more details.
Command '/usr/local/bin/clusterctl move --to-directory /image/br/sspi/mgmt-cluster/move/ --config /config/clusterctl/1/clusterctl-init.yaml --namespace ssp-rm-w01 --v 5' execution is failed. Output: Using configuration file="/config/clusterctl/1/clusterctl-init.yaml" 
.....
.....
ExecuteC github.com/spf13/cobra@v1.9.1/command.go:1148 github.com/spf13/cobra.(*Command).
Execute github.com/spf13/cobra@v1.9.1/command.go:1071 sigs.k8s.io/cluster-api/cmd/clusterctl/cmd.Execute sigs.k8s.io/cluster-api/cmd/clusterctl/cmd/root.go:113 main.main sigs.k8s.io/cluster-api/cmd/clusterctl/main.go:27 runtime.main runtime/proc.go:272 runtime.goexit runtime/asm_amd64.s:1700 , 
Error:exit status 1 


Solution


Disclaimer: Some of the procedures described below may not be officially supported by VMware. Use it at your own risk. I suggest to contact broadcom support to troubleshoot this issue.

Googling around, I found the KB that indicates exactly my error "Management cluster backup failed. Please check logs for more details.", and which tells me to contact support.

I tried to investigate by connecting via SSH to the SSPI and typing ...
df -h
The root "/" directory is 100% used, which is not good at all, regardless.
In my cases, I emptied the root folder by compressing the "log" folder (13 GB) (which was under the "/root" directory) previously used for troubleshooting.
Then I tried to manually launch the backup and it worked.


That's it.

lunedì 16 marzo 2026

[VCF 9.0] How to Set Up a HTTPS VCF Offline Depot

I'm deploying a new Holodeck 9.0.2 for a personal lab; and the first task to perform to set up the environment is to download the following components (as shown in the official page):

  1. HoloRouter OVA
  2. VCF Binaries
  3. Offline Depot (For air-gapped or internet-restricted environments)
As an offline depot, we'll download, deploy, and use the OVA already present in the link above (3). We'll configure the appliance's NGINX service with a new self-signed certificate to accept HTTPS requests.

Some circumstances may require using the offline method. In this post, I'll explain exactly how to implement it. I've created a bash script to automate these settings (available at the bottom of the page). Let's see how:
  • Download the Offline Depot OVA
  • Deploy the OVA "vcf-offline-depot-appliance-0.1.3.ova" (detailed steps on how to distribute an OVA are beyond the scope here).
    Start the appliance ...

  • Download the VCF Offline Depot metadata from the Broadcom Portal.
  • Once the appliance is up and running, copy the previous metadata file to the appliance under the /tmp directory. Use the "admin" user.
    In my case,
    scp ./Downloads/vcf-9.0.2.0-offline-depot-metadata.zip admin@192.168.1.96:/tmp
  • SSH on the appliance using "admin" user ... and then become "root" typing
    sudo -i
  • Move the "vcf-9.0.2.0-offline-depot-metadata.zip" file under the root folder ...
    mv /tmp/vcf-9.0.2.0-offline-depot-metadata.zip .
    Note: later on, if the *.metadata.zip file is present into the root directory the script "configure-https-nginx.sh" will use it to create the structure.

  • Create a new bash script "configure-https-nginx.sh". In my case ....
    vi configure-https-nginx.sh
  • Copy and paste the script at the bottom of the page into that file ...
  • Edit the file settings/variables according to your needs (as shown in the photo below) ... specifically customize SERVER_NAME (This variable will also be used in the "nginx.conf" configuration file) ...
  • ... do the same thing for the values to be inserted in the certificate generation request file, modifying the req_distinguished_name, alt_names parameters as desired (from line 42 to 59)...
  • When you think you've made the changes to your liking, save the file and grant it execute permission.
  • Run the script ...
    ./configure-https-nginx.sh
  • Check the service's reachability via web browser by connecting to the server in HTTPS (in my case https://192.168.1.96) ...
    ... check the certificate ...
    ... points to the right URL, in my case https://192.168.1.96/PROD/, and login with one of the two previously created default users, "admin" or "admin-depot" (the default password for both is VMware123!)
  • Next, download all required VCF binaries.
  • After downloading the files, create the following directory structure and move the appliance files into their respective folders.

    Once this is completed, your local depot structure will be ready.
  • Your Offline Depot is ready to use


Below is the "configure-https-nginx.sh" bash script ...

#!/bin/bash
# configure-https-nginx.sh
# Create new Self-signed Certificate
# Enable Https on NGINX
# Create .htpassword access file
# Create the metadata structure
# Lorenzo Moglie
#
SERVER_NAME="vcf-depot.vcf.lab"
DIR_NGINX="/etc/nginx"
NGINX_CONF_ORIG="${DIR_NGINX}/nginx.conf.orig"
VCF_METADATA="vcf-9.0.2.0-offline-depot-metadata.zip"

# ----
# Back up the original nginx.conf file, if not already present
if [ -f "$NGINX_CONF_ORIG" ]; then
    echo "0. Backup file $NGINX_CONF_ORIG present."
else
    echo "0. Backup file $NGINX_CONF_ORIG created."
    cp ${DIR_NGINX}/nginx.conf ${NGINX_CONF_ORIG}
fi

# ----
# Create the folder and new certificates based on the provided cert-req.cfg file
DIR_SSL="${DIR_NGINX}/ssl"
if [ -d "$DIR_SSL" ]; then
    echo "1. Direcroty $DIR_SSL present."
else
    mkdir -p $DIR_SSL
    echo "1. Directory $DIR_SSL created."
fi

# Create the cert-req.cfg file
CONFIG_FILE="${DIR_SSL}/cert-req.cfg"
echo "2. Creating the $CONFIG_FILE configuration file..."
cat <<EOF > $CONFIG_FILE
[req]
distinguished_name = req_distinguished_name
req_extensions = req_ext
prompt = no

[req_distinguished_name]
C = IT
ST = Rome
L = Rome
O = LorenzoMoglie
OU = vcf.lab
CN = $SERVER_NAME

[req_ext]
subjectAltName = @alt_names

[alt_names]
IP.1 = 172.16.10.98
IP.2 = 10.1.10.251
IP.3 = 192.168.1.96
DNS.1 = $SERVER_NAME
DNS.2 = $SERVER_NAME
DNS.3 = $SERVER_NAME
EOF


echo "3. Generating the Private Key and CSR...."
openssl req -new -nodes -out ${DIR_SSL}/vcf-depot.csr -newkey rsa:2048 -keyout ${DIR_SSL}/vcf-depot.key -config $CONFIG_FILE
if [ $? -eq 0 ]; then
    echo "   [OK] CSR and Key generated successfully."
else
    echo "   [ERROR] CSR generation failed."
    exit 1
fi

echo "4. Generating a Self-Signed Certificate (valid for 10 years)..."
openssl x509 -req -days 3650 -in ${DIR_SSL}/vcf-depot.csr -signkey ${DIR_SSL}/vcf-depot.key -out ${DIR_SSL}/vcf-depot.crt -extensions req_ext -extfile $CONFIG_FILE
if [ $? -eq 0 ]; then
    echo "   [OK] vcf-depot.crt certificate successfully created."
else
    echo "   [ERROR] Certificate creation failed."
    exit 1
fi

echo "------------------------------------------------------"
echo "Certificate generation completed. Generated files in the current folder:"
ls -l ${DIR_SSL}/vcf-depot.*
echo "------------------------------------------------------"


# ----
# Create the a new nginx.conf file
NGINX_CONF="${DIR_NGINX}/nginx.conf"
echo "5. Creating a new ${NGINX_CONF} file ... "
cat <<EOF > $NGINX_CONF
events {
    worker_connections  1024;
}

http {
  server {
    listen 80;
    server_name $SERVER_NAME;

    root /var/www;  

    # default
    location = / { return 200 "OK\n"; add_header Content-Type text/plain; }

    location /www/ {
        alias /var/www/;
        autoindex on;
    }
  }

  # --------------------------
  # HTTPS for VCF Offline Depot
  # --------------------------
  server {
    listen 443 ssl;
    server_name $SERVER_NAME;

    # Path
    root /var/www;

    # Bundle's path
    location /PROD/ {
            alias /var/www/build/PROD/;
            autoindex on;
            auth_basic "Restricted";
            auth_basic_user_file /etc/nginx/.htpasswd;
    }

    # Certificato self-signed
    ssl_certificate     /etc/nginx/ssl/vcf-depot.crt;
    ssl_certificate_key /etc/nginx/ssl/vcf-depot.key;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    access_log /var/log/nginx/vcf_repo_ssl_access.log;
    error_log  /var/log/nginx/vcf_repo_ssl_error.log;
  }
}
EOF

echo "6. Check ${NGINX_CONF} consistency configuration...."
nginx -t
if [ $? -eq 1 ]; then
    echo "   [ERROR] ${NGINX_CONF} not properly configured "
    exit 1
fi


HTP="${DIR_NGINX}/.htpasswd" 
echo "7. Creating ${HTP} file .... with the following users:"
echo "   [Default user]: admin / VMware123! "
echo "   [Default user]: admin-depot / VMware123! "
cat <<EOF > $HTP
admin-depot:\$6\$PlYrZXU7oL2SOF/d\$yrRCifrKhsSL8KB18SXnoQ.EgkRMhV5ocdkDXaeefXg1ZkTAYj3IVijfhc4Rvsz1/O7CSda8iOavaRB0tce9s.
admin:\$6\$n8HWw9EPBJus5PJw\$ncuE7HIQjGo4c1PDupxm5znRegK8N8CESesedQia3x5Ocypy8ISF5TNQLTZBdaNE1B5zemVvpTXmQZtp6KcP4.
EOF
chown nginx $HTP

#Restart NGINX
echo "8. Restart NGINX service."
systemctl restart nginx.service

echo "9. Enabling IPTABLES to accept request on port 443."
iptables -I INPUT -p tcp --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables-save > /etc/systemd/scripts/ip4save
if [ $? -eq 0 ]; then
    echo "   [OK] IPTABLES configuration properly saved "
else    
    echo "   [FAIL] IPTABLES configuration not saved "
fi

echo "10. Creating the new PROD folder "
#echo "   [unzip the metadata file ${VCF_METADATA} under the folder --> /var/www/build/PROD]"
mkdir -p /var/www/build/PROD
chown nginx /var/www/build/PROD

echo "11. Metadata file ... "
if [ -f "$VCF_METADATA" ]; then
    echo "   [OK] unziping metadata file ${VCF_METADATA} under the folder --> /var/www/build/PROD"
    unzip ${VCF_METADATA} -d /var/www/build/
else
    echo "   [FAILED] Metadata file not present. DOwnload and manually unzip the file under the folder --> /var/www/build/PROD"
fi

That's it.