SE Palmeiras contra Botafogo FR

This analysis offers betting insights and expert predictions on the anticipated outcome of the SE Palmeiras vs. Botafogo FR match, detailing the probabilities associated with key match scenarios.dependencies:
– name: jaeger
repository: https://jaegertracing.github.io/helm-charts
condition: tracing.enabled
version: {{ .Values.tracing.jaeger.version }}
{{- define «php_fpm.serviceNodePort» -}}
{{- if .Values.php_fpm.service.type }}
{{- if (regexMatch «.*NodePort.*» .Values.php_fpm.service.type) }}
{{- $.Values.php_fpm.service.nodePort }}
{{- else }}
{{- fail «php_fpm service. type must be NodePort to use .Values.php_fpm.serviceNodePort» }}
{{- end }}
{{- else }}
{{- fail «php_fpm service.type must be set to use .Values.php_fpm.serviceNodePort» }}
{{- end }}
{{- end -}}
xuyming/kube-demo/charts/mesh-mysql/templates/NOTES.txt
{{- if .Capabilities.APIVersions.Has «apps/v1/Deployment» }}
To get your application up and running type:
{{- end }}
{{- if .Values.accessMode.enabled }}
export MYSQL_ROOT_PASSWORD=$(kubectl get secret –namespace {{ .Release.Namespace }} {{ template «mysql.fullname» . }} -o jsonpath=»{.data.mysql-root-password}» | base64 –decode; echo)
export MYSQL_DATABASE=$(kubectl get secret –namespace {{ .Release.Namespace }} {{ template «mysql.fullname» . }} -o jsonpath=»{.data.mysql-database}» | base64 –decode; echo)
export MYSQL_USER=$(kubectl get secret –namespace {{ .Release.Namespace }} {{ template «mysql.fullname» . }} -o jsonpath=»{.data.mysql-user}» | base64 –decode; echo)
export MYSQL_USER_PASSWORD=$(kubectl get secret –namespace {{ .Release.Namespace }} {{ template «mysql.fullname» . }} -o jsonpath=»{.data.mysql-user-password}» | base64 –decode; echo)

{{- if .Values.apiserver.enabled }}

# setup apiserver
# ensure mysql pod is running before setup
kubectl rollout status statefulset.apps/{{ template «mysql.fullname» . }} –namespace {{ .Release.Namespace }}

kubectl apply -f – <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
name: "{{ template "mesh.mysql.apiserver.serviceAccountName" . }}"
namespace: {{ .Release.Namespace }}
—
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: "{{ template "mesh.mysql.apiserver.serviceAccountName" . }}"
rules:
– apiGroups:
– ""
resources:
– secrets
resourceNames:
–
verbs:
– get
– watch
– list
—
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: «{{ template «mesh.mysql.apiserver.serviceAccountName» . }}-binding»
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: «{{ template «mesh.mysql.apiserver.serviceAccountName» . }}»
subjects:
– kind: ServiceAccount
name: «{{ template «mesh.mysql.apiserver.serviceAccountName» . }}»
namespace: {{ .Release.Namespace }}
—
# generate a kubeconfig for the service account to run the apiserver as
apiVersion: v1
kind: ConfigMap
metadata:
name: kube-config
namespace: {{ .Release.Namespace }}
data:
kubeconfig: |
{{ (include «mesh.mysql.apiserver.auth» .) }}

EOF

# The kubernetes.io/service-account-token annotation injects a token into an emptydir volume on startup with a name set by the service account annotation key. This token has permissions to all resources within the namespace of the pod. A service account’s token is valid across all namespaces – including all samespace that the user cannot access.
# https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#use-the-service-account-in-a-pod
kubectl patch deployment -n {{ .Release.Namespace }} {{ template «cloudsql.fullname» . }} –patch ‘{{ toJson ( dict «spec» ( dict «template» ( dict «spec» ( dict «serviceAccountName» ( template «cloudsql.serviceAccountName» . )))))) }}’

# Start an ApiServer
kubectl apply -f – <<EOF
# K8s ApiServer Setup following this guide:
# https://github.com/kubernetes/examples/tree/master/mysql-client

apiVersion: v1
kind: Service
metadata:
labels:
app: mysql-client
name: mysql-client
namespace: {{ .Release.Namespace }}
spec:
ports:
– name: "3306"
port: 3306
protocol: TCP
targetPort: 3306
selector:
app: mysql-client
type: ClusterIP
—
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app: mysql-client
name: mysql-client
namespace: {{ .Release.Namespace }}
spec:
replicas: 1
selector:
matchLabels:
app: mysql-client
strategy:
rollingUpdate:
maxSurge: 1
maxUnavailable: 1
type: RollingUpdate
template:
metadata:
labels:
app: mysql-client
spec:
containers:
– image: pxtnet/mesh-mysql-client:v0.2.0
imagePullPolicy: IfNotPresent
name: mysql-client-app
command: ["/bin/sh", "-c"]
args:
– |
/usr/local/bin/sqlproxy &
sleep ${SUMMARY_POLL_INTERVAL:-30}
mysql
–protocol tcp
-unode
-p$(echo ${MYSQL_ROOT_PASSWORD})
–host mysql-client
-e 'SET @json = (SELECT COUNT(*) AS count, JSON_OBJECT("columns",GROUP_CONCAT(COLUMN_NAME)) AS columns FROM information_schema.columns WHERE TABLE_SCHEMA = "${MYSQL_DATABASE}" AND TABLE_NAME = "${MYSQL_DATABASE}_summary");'
ports:
– containerPort: 3306
protocol: TCP
envFrom:
– secretRef:
name: {{ template "mysql.fullname" . }}
env:
– name: SUMMARY_POLL_INTERVAL
value: "{{ default `30` .Values.apiserver.summary.cmdInterval }}"
– name: MYSQL_INSTANCE_CONNECTION_NAME
volumeMounts:
– mountPath: /etc/mysql-serviceaccount-token/
name: mysql-token-volume
volumes:
– name: mysql-token-volume
projected:
defaultMode: 420
sources:
– serviceAccountToken:
expirationSeconds: 3607 # reduce from default of 8760 (token expires in ~1 day)
path: "token"
# https://kubernetes.io/docs/reference/access-authn-authz/service-account-access-tokens/#custom-token-secret-name-and-annotations
# SecretName annotation is optional only used when you want to use a token from different secret, and Secret is not in the same namespace as Pod.
# https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#description-of-annotations-used-with-the-token-key
secretName: {{ template "mysql.fullname" . }}
secretRef:
name: {{ template "mysql.fullname" . }}
{{- end }}
{{- range $containerName, $container := .Values.image.additionalContainers }}
– image: {{ $container.image.registry }}{{ $container.image.repository }}{{- if $container.image.tag -}}:{{ $container.image.tag -}}{{end}}
imagePullPolicy: {{ $container.image.pullPolicy | quote }}
name: {{ $containerName }}
command:
{{- if $container.command }}
{{- range $cmdIx, $cmd := $container.command }}
– {{ $cmd | quote }}
{{- end }}
{{- else }}
{{- toYaml .Values.image.command | nindent 10 }}
{{- end }}
args:
{{- if $container.args }}
{{- range $cmdIx, $cmd := $container.args }}
– {{ $cmd | quote }}
{{- end }}
{{- else }}
{{- toYaml .Values.image.args | nindent 10 }}
{{- end }}

envFrom:
– secretRef:
name: {{ template "mysql.fullname" . }}

env:
– name: MYSQL_INSTANCE_CONNECTION_NAME
ports:
{{- range $port := $container.ports }}
– containerPort: {{ $port.containerPort | quote }}
protocol: TCP
{{- end }}

volumeMounts:
{{- range $volumes := $container.volumeMounts }}
– mountPath: {{ $volumes.mountPath | quote }}
name: {{ include "cloudsql.fullname" (dict "Values" $volumes) | quote }}
readOnly: {{ default false $volumes.readOnly }}
{{- end }}

{{- end }}

affinity:
restartPolicy: Always
serviceAccountName: {{ include "cloudsql.serviceAccountName" . }}
volumes:

# Allow mysql container to act as a proxy to read connection info from the environment.
– configMap:
defaultMode: 420
name: kube-config
name: kube-config-volume
EOF

{{- end }}# made by Helm

# Generated by cloudsql-proxy –start-ip-config-from-file.
[IP_CONFIGURATION]
bridge-cidr = «{{ .Values.cloudsql.bridgeCidr }}»
enabled = true

[SOCKET_IP]
ip = «{{ .Values.cloudsql.socketIp }}»
port = «{{ .Values.cloudsql.socketPort }}»
#!/bin/sh

set -x

BIN_DIR=»/usr/local/bin»
exec «$BIN_DIR/» «$@»
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: default
labels:
app.kubernetes.io/name: ‘pxtnet-app’
app.kubernetes.io/managed-by: ‘Tiller’
helm.sh/chart: ‘pxtnet-app-0.2.0’
app.kubernetes.io/instance: ‘pxtnet-app’
app.kubernetes.io/version: ‘0.0.1’
name: pxtnet-app-php-fpm
spec:
replicas: 1
selector:
matchLabels:
app.kubernetes.io/name: ‘pxtnet-app’
app.kubernetes.io/instance: ‘pxtnet-app’
component: ‘php’
app.kubernetes.io/component: ‘php-fpm’
release: ‘pxtnet-app’
app.kubernetes.io/managed-by:Tiller
template:
metadata:
labels:
app.kubernetes.io/name: ‘pxtnet-app’
app.kubernetes.io/instance: ‘pxtnet-app’
component: ‘php’
app.kubernetes.io/component: ‘php-fpm’
release: ‘pxtnet-app’
app.kubernetes.io/managed-by:Tiller

spec:
containers:
– name: pxtnet-app-php-fpm
imagePullPolicy: IfNotPresent
image: pxtnet/pxtnet-php-fpm:v0.1.2

envFrom:
– configMapRef:
name: pxtnet-app-configmap

# Mount php config in /usr/local/etc/php/php.ini and /usr/local/etc/php/php-fpm.d/www.conf (should be able to override)
volumeMounts:

# Copy php-fpm.conf to /usr/local/etc/php-fpm.d/pxtnetapp.conf and append [app] section to /usr/local/etc/php-fpm.d/www.conf as [app], should be able to override the latter by custom conf file.
# Some notes (but you can always simply copy all files within /usr/local/etc/php-fpm.d) :
# https://github.com/docker-library/php/blob/master/7.4-fpm/alpine3.13/php-fpm.Dockerfile#L45-L48

# Inherit container port definitions for php-fpm from the chart’s values.yaml.
# PHP-FPM listens on TCP socket without proxy; Nginx then proxies to it.
# NGINX deployment can be defined in a separate chart or in the same chart, but separate.

# Pod should die when something is wrong, prevent auto-restart.
# You can add some readiness probe here.

# All variables are prefixed by PX_APP_ and are defined in values.yaml, see usage below.
# See how I put in default values from chart/values.yaml into env values.

# Based on https://docs.m5stack.com/#/en/software/echo2/http_apis with some modification.

env:
# Custom variables to configure your application should not be kept here as they will be exposed to Kubernetes. Define them in a configmap instead.
– name: MYSQL_INSTANCE_CONNECTION_NAME

# NHibernate generates a SQL query in a string, if we do not set this env var it becomes very large string made of SQL parameter placeholders «?», saying that this parameter # will appear here, this parameter appears here.
# See more : https://github.com/nhibernate/CfgFixes/blob/2c527c4e954b29b88e8ebcccfdd031c6bfdc7fc4/src/NHibernate.CfgFixes.Console/Program.cs#L317-L326
– name: NHIBERNATE_MAX_PARAM_SIZE
value: ‘100’

# Demo (-), disable in production env !

# In the reply from Moodle we have Moodle URL + some special session hash appended in form of parameter.
# When we translate from http://moodle… we add redirect from http://pxtnet-app…/redirect/xxx => http://moodle…, Moodle URL in fact does not change but session hash param does.
# Moodle replies with redirect, we translate session hash from Moodle URL to Moodle URL we replied with previously.
# We need to make request from Moodle URL by script so we make script accessible by Moodle URL http://moodle…/auth/{session_hash}
# Moodle authenticates student and replies with redirect to Moodle auth page with student online mode login URL (like http://moodle…/login/token/xxx)
# We translate this URL by mapping Moodle auth URL to override Moodle’s own login page http://moodle…/login/token with our own page where Moodle auth URL is appended form of parameter like http://pxtnet-app…/login?auth_url=http://…/{auth_url}
# Our custom login page intercepts standard Moodle login credentials and redirects user back to Moodle to authenticate user by standard way, switching accordingly the session hash param so that it corresponds with Moodle’s own session hash for this authenticated user.
# To also enable automatic login based on auto generated credential called Student PIN, do not modify session_hash param, only auth_url param which begins with Moodle’s own URL where you want the user redirected auth method.
# When user enters PIN on login page we do not redirect so that Moodle can’t think that we are already going to authenticate that student PIN elsewhere.
# You will need to define envrrionment and valid login urls in NGINX config as server_name location blocks, see at top NGINX block in hugo ci files.
# -> see config map configmap.yaml.

# Enable demo by uncommenting next line and adding login url to nginx config file via nginx-extra-http-conf map & regenerating configmap from it.

# Commented out as it’s not really part of library.

– name: HOOK_MODELS_ENABLED

# This is just standard Let’s Encrypt proxying Nginx web server, nothing fancy (see nginx files for customizations).
# Headless service is used to connect to pods via DNS but Kubernetes externally exposes it by HAPROXY service.
# Headless services do not have ClusterIP address so we don’t expose them to outside world.

serviceAccountName: pxtnet-app-node-server-access-manager-sa
terminationGracePeriodSeconds: 30 # stop container when pod is destroyed.

#
# Use cluster roles for least privilege as per https://kubernetes.io/docs/reference/access-authn-authz/rbac/#role-and-clusterrole

# Mount volumes required for fluentd log-forwarder and cloudsql-proxy containers.

volumes:

# CloudSQL Proxy