Dat is krekt, nei frijlitting oan it begjin fan maaie 2019, yn Consul kinne jo applikaasjes en tsjinsten autorisearje dy't native yn Kubernetes rinne.
Yn dizze tutorial sille wy stap foar stap meitsje (Proof of concept, PoC) dy't dizze nije funksje demonstrearje. Jo wurde ferwachte dat jo basiskennis hawwe fan Kubernetes en Hashicorp's Consul. Wylst jo elk wolkplatfoarm of on-premises omjouwing kinne brûke, sille wy yn dizze tutorial Google's Cloud Platform brûke.
oersjoch
As wy gean nei , krije wy in fluch oersjoch fan it doel en gebrûksgefal, en ek wat technyske details en in algemien oersjoch fan 'e logika. Ik riede it sterk oan om it op syn minst ien kear te lêzen foardat ik trochgie, om't ik no alles sil útlizze en kauwen.
Diagram 1: Offisjele oersjoch fan 'e Consul-autorisaasjemetoade
Litte wy nei binnen sjen .
Wis, d'r is dêr nuttige ynformaasje, mar d'r is gjin hantlieding oer hoe't jo it allegear eins brûke kinne. Dat, lykas elke ferstannige persoan, skodzje jo it ynternet foar begelieding. En dan... Jo mislearje. It bart. Litte wy dit reparearje.
Foardat wy trochgean mei it meitsjen fan ús POC, litte wy weromgean nei it oersjoch fan de autorisaasjemetoaden fan Consul (Diagram 1) en ferfine it yn 'e kontekst fan Kubernetes.
arsjitektuer
Yn dit tutorial sille wy in Consul-tsjinner oanmeitsje op in aparte masine dy't sil kommunisearje mei in Kubernetes-kluster mei de Consul-kliïnt ynstalleare. Wy sille dan ús dummy-applikaasje yn 'e pod oanmeitsje en ús ynstelde autorisaasjemetoade brûke om te lêzen fan ús Consul-kaai-/weardewinkel.
It diagram hjirûnder beskriuwt de arsjitektuer dy't wy meitsje yn dizze tutorial, lykas de logika efter de autorisaasjemetoade, dy't letter sil wurde útlein.
Diagram 2: Kubernetes Autorisaasje Metoade Oersjoch
In rappe opmerking: de Consul-tsjinner hoecht net bûten it Kubernetes-kluster te wenjen om dit te wurkjen. Mar ja, hy kin it sa en sa.
Dat, as wy it Diagram oersjoch fan Consul (Diagram 1) nimme en Kubernetes derop tapasse, krije wy it diagram hjirboppe (Diagram 2), en de logika hjir is as folget:
- Elke pod sil in tsjinstakkount hawwe taheakke mei in JWT-token oanmakke en bekend troch Kubernetes. Dizze token wurdt ek standert ynfoege yn 'e pod.
- Us applikaasje of tsjinst binnen de pod inisjearret in oanmeldkommando foar ús Consul-kliïnt. It oanmeldfersyk sil ek ús token en namme befetsje spesjaal makke autorisaasje metoade (Kubernetes type). Dizze stap #2 komt oerien mei stap 1 fan it Consul-diagram (skema 1).
- Us Consul-kliïnt sil dit fersyk dan trochstjoere nei ús Consul-tsjinner.
- MAGIC! Dit is wêr't de Consul-tsjinner de autentisiteit fan it fersyk kontrolearret, ynformaasje sammelt oer de identiteit fan it fersyk en fergeliket it mei alle assosjearre foarôf definieare regels. Hjirûnder is in oar diagram om dit te yllustrearjen. Dizze stap komt oerien mei stappen 3, 4 en 5 fan it Consul-oersjochdiagram (diagram 1).
- Us Consul-tsjinner genereart in Consul-token mei tagongsrjochten neffens ús spesifisearre regels foar autorisaasjemetoade (dy't wy hawwe definieare) oangeande de identiteit fan 'e oanfreger. It sil dan dat token werom stjoere. Dit komt oerien mei stap 6 fan it Consul-diagram (diagram 1).
- Us Consul-kliïnt stjoert it token troch nei de oanfreegjende applikaasje of tsjinst.
Us applikaasje of tsjinst kin no dit Consul-token brûke om te kommunisearjen mei ús Consul-gegevens, lykas bepaald troch de privileezjes fan it token.
De magy wurdt iepenbiere!
Foar dyjingen dy't net bliid binne mei gewoan in haas út 'e hoed en wolle witte hoe't it wurket ... lit my "jo sjen litte hoe djip kninehol".
Lykas earder neamd, is ús "magyske" stap (figuer 2: Stap 4) wêr't de Consul-tsjinner it fersyk autentisearret, sammelt ynformaasje oer it fersyk en fergeliket it mei alle assosjearre foarôf definieare regels. Dizze stap komt oerien mei stappen 3, 4 en 5 fan it Consul-oersjochdiagram (diagram 1). Hjirûnder is in diagram (diagram 3), wêrfan it doel is dúdlik sjen te litten wat der eins bart ûnder de motorkap spesifike Kubernetes autorisaasje metoade.
Diagram 3: De magy wurdt iepenbiere!
- As útgongspunt stjoert ús Consul-kliïnt it oanmeldfersyk troch nei ús Consul-tsjinner mei it Kubernetes-akkount-token en spesifike eksimplaarnamme fan 'e autorisaasjemetoade dy't earder makke is. Dizze stap komt oerien mei stap 3 yn de foarige circuit taljochting.
- No moat de Consul-tsjinner (as lieder) de autentisiteit fan it ûntfongen token ferifiearje. Dêrom sil it it Kubernetes-kluster rieplachtsje (fia de Consul-kliïnt) en, mei de passende tagongsrjochten, sille wy útfine oft it token echt is en wa't it heart.
- It falidearre fersyk wurdt dan weromjûn oan de Consul-lieder, en de Consul-tsjinner siket de autorisaasjemetoade-eksimplaar op mei de opjûne namme fan it oanmeldfersyk (en Kubernetes-type).
- De konsullieder identifisearret de oantsjutte autorisaasjemetoade-eksimplaar (as fûn) en lêst de set fan binende regels dy't deroan binne. It lêst dan dizze regels en fergeliket se mei de ferifiearre identiteitsattributen.
- TA-dah! Lit ús gean nei stap 5 yn de foarige circuit taljochting.
Run Consul-tsjinner op in gewoane firtuele masine
Fan no ôf sil ik meast ynstruksjes jaan oer hoe't jo dizze POC meitsje kinne, faak yn kûgelpunten, sûnder folsleine sinútlis. Ek, lykas earder opmurken, sil ik GCP brûke om alle ynfrastruktuer te meitsjen, mar jo kinne deselde ynfrastruktuer oeral oars oanmeitsje.
- Start de firtuele masine (eksimplaar / tsjinner).
- Meitsje in regel foar de firewall (befeiligingsgroep yn AWS):
- Ik wol graach deselde masinenamme tawize oan sawol de regel as it netwurktag, yn dit gefal "skywiz-consul-server-poc".
- Fyn it IP-adres fan jo lokale kompjûter en foegje it ta oan 'e list mei boarne IP-adressen, sadat wy tagong krije ta de brûkersynterface (UI).
- Iepenje haven 8500 foar UI. Klik oanmeitsje. Wy sille dizze firewall gau wer feroarje [].
- Foegje in firewall-regel ta oan it eksimplaar. Gean werom nei it VM-dashboard op Consul Server en foegje "skywiz-consul-server-poc" ta oan it netwurk tags fjild. Klik op Bewarje.
- Ynstallearje Consul op in firtuele masine, kontrolearje hjir. Unthâld dat jo Consul-ferzje ≥ 1.5 nedich binne [keppeling]
- Lit ús meitsje in inkele knooppunt Consul - de konfiguraasje is as folget.
groupadd --system consul
useradd -s /sbin/nologin --system -g consul consul
mkdir -p /var/lib/consul
chown -R consul:consul /var/lib/consul
chmod -R 775 /var/lib/consul
mkdir /etc/consul.d
chown -R consul:consul /etc/consul.d- Foar in mear detaillearre hantlieding oer it ynstallearjen fan Consul en it ynstellen fan in kluster fan 3 knopen, sjoch .
- Meitsje in triem /etc/consul.d/agent.json as folget []:
### /etc/consul.d/agent.json
{
"acl" : {
"enabled": true,
"default_policy": "deny",
"enable_token_persistence": true
}
}- Start ús Consul-tsjinner:
consul agent
-server
-ui
-client 0.0.0.0
-data-dir=/var/lib/consul
-bootstrap-expect=1
-config-dir=/etc/consul.d- Jo moatte in boskje útfier sjen en einigje mei "... update blokkearre troch ACL's."
- Fyn it eksterne IP-adres fan 'e Consul-tsjinner en iepenje in browser mei dit IP-adres op poarte 8500. Soargje derfoar dat de UI iepenet.
- Besykje in kaai / wearde-pear ta te foegjen. Der moat in flater wêze. Dit is om't wy de Consul-tsjinner laden hawwe mei in ACL en alle regels útskeakele.
- Gean werom nei jo shell op 'e Consul-tsjinner en begjin it proses op' e eftergrûn of op in oare manier om it te rinnen en fier it folgjende yn:
consul acl bootstrap- Fyn de "SecretID" wearde en werom nei de UI. Fier yn it ljepblêd ACL de geheime ID yn fan it token dat jo krekt kopieare. Kopiearje SecretID earne oars, wy sille it letter nedich hawwe.
- Foegje no in kaai / weardepaar ta. Foar dizze POC, foegje de folgjende ta: kaai: "custom-ns/test_key", wearde: "Ik bin yn 'e oanpaste-ns map!"
In Kubernetes-kluster lansearje foar ús applikaasje mei de Consul-kliïnt as Daemonset
- Meitsje in K8s (Kubernetes) kluster. Wy meitsje it yn deselde sône as de tsjinner foar fluggere tagong, en dus kinne wy itselde subnet brûke om maklik te ferbinen mei ynterne IP-adressen. Wy sille it "skywiz-app-with-consul-client-poc" neame.
- As side-notysje is hjir in goede tutorial dy't ik tsjinkaam by it ynstellen fan in POC Consul-kluster mei Consul Connect.
- Wy sille ek Hashicorp-helmkaart brûke mei in útwreide weardebestân.
- Ynstallearje en konfigurearje Helm. Konfiguraasjestappen:
kubectl create serviceaccount tiller --namespace kube-system
kubectl create clusterrolebinding tiller-admin-binding
--clusterrole=cluster-admin --serviceaccount=kube-system:tiller
./helm init --service-account=tiller
./helm update- roer diagram:
- Brûk de folgjende weardebestân (notysje dat ik de measte útskeakele haw):
### poc-helm-consul-values.yaml
global:
enabled: false
image: "consul:latest"
# Expose the Consul UI through this LoadBalancer
ui:
enabled: false
# Allow Consul to inject the Connect proxy into Kubernetes containers
connectInject:
enabled: false
# Configure a Consul client on Kubernetes nodes. GRPC listener is required for Connect.
client:
enabled: true
join: ["<PRIVATE_IP_CONSUL_SERVER>"]
extraConfig: |
{
"acl" : {
"enabled": true,
"default_policy": "deny",
"enable_token_persistence": true
}
}
# Minimal Consul configuration. Not suitable for production.
server:
enabled: false
# Sync Kubernetes and Consul services
syncCatalog:
enabled: false- Rordiagram tapasse:
./helm install -f poc-helm-consul-values.yaml ./consul-helm - name skywiz-app-with-consul-client-poc- As it besiket te rinnen, sil it tagongsrjochten nedich hawwe foar de Consul-tsjinner, dus litte wy se tafoegje.
- Notysje de "Pod Address Range" leit op it kluster dashboard en ferwize werom nei ús "skywiz-consul-server-poc" firewall regel.
- Foegje it adresberik foar de pod ta oan de list mei IP-adressen en iepenje de havens 8301 en 8300.
- Gean nei de Consul UI en nei in pear minuten sille jo ús kluster sjen ferskine yn it ljepblêd knopen.
In autorisaasjemetoade konfigurearje troch Consult te yntegrearjen mei Kubernetes
- Gean werom nei de Consul-tsjinner shell en eksportearje it token dat jo earder bewarre hawwe:
export CONSUL_HTTP_TOKEN=<SecretID>- Wy sille ynformaasje nedich hawwe fan ús Kubernetes-kluster om in eksimplaar fan 'e auth-metoade te meitsjen:
- kubernetes-host
kubectl get endpoints | grep kubernetes- kubernetes-service-account-jwt
kubectl get sa <helm_deployment_name>-consul-client -o yaml | grep "- name:"
kubectl get secret <secret_name_from_prev_command> -o yaml | grep token:- It token is base64 kodearre, dus ûntsiferje it mei jo favorite ark []
- kubernetes-ca-cert
kubectl get secret <secret_name_from_prev_command> -o yaml | grep ca.crt:- Nim it sertifikaat "ca.crt" (nei base64-dekodearring) en skriuw it yn it "ca.crt"-bestân.
- Instantiearje no de auth-metoade, ferfange de plakhâlders mei de wearden dy't jo krekt hawwe ûntfongen.
consul acl auth-method create
-type "kubernetes"
-name "auth-method-skywiz-consul-poc"
-description "This is an auth method using kubernetes for the cluster skywiz-app-with-consul-client-poc"
-kubernetes-host "<k8s_endpoint_retrieved earlier>"
[email protected]
-kubernetes-service-account-
jwt="<decoded_token_retrieved_earlier>"- Dêrnei moatte wy in regel meitsje en it oan 'e nije rol heakje. Foar dit diel kinne jo Consul UI brûke, mar wy sille de kommandorigel brûke.
- Skriuw in regel
### kv-custom-ns-policy.hcl
key_prefix "custom-ns/" {
policy = "write"
}- Tapasse de regel
consul acl policy create
-name kv-custom-ns-policy
-description "This is an example policy for kv at custom-ns/"
-rules @kv-custom-ns-policy.hcl- Fyn de ID fan 'e regel dy't jo krekt makke hawwe fanút de útfier.
- Meitsje in rol mei in nije regel.
consul acl role create
-name "custom-ns-role"
-description "This is an example role for custom-ns namespace"
-policy-id <policy_id>- No sille wy ús nije rol assosjearje mei it eksimplaar fan auth-metoade. Tink derom dat de flagge "selektor" bepaalt oft ús oanmeldingsfersyk dizze rol krijt. Kontrolearje hjir foar oare seleksjeopsjes:
consul acl binding-rule create
-method=auth-method-skywiz-consul-poc
-bind-type=role
-bind-name='custom-ns-role'
-selector='serviceaccount.namespace=="custom-ns"'As lêste konfiguraasjes
Tagongsrjochten
- Meitsje tagongsrjochten. Wy moatte Consul tastimming jaan om de identiteit fan 'e K8s tsjinstkontotoken te ferifiearjen en te identifisearjen.
- Skriuw it folgjende nei it bestân :
###skywiz-poc-consul-server_rbac.yaml
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: review-tokens
namespace: default
subjects:
- kind: ServiceAccount
name: skywiz-app-with-consul-client-poc-consul-client
namespace: default
roleRef:
kind: ClusterRole
name: system:auth-delegator
apiGroup: rbac.authorization.k8s.io
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: service-account-getter
namespace: default
rules:
- apiGroups: [""]
resources: ["serviceaccounts"]
verbs: ["get"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: get-service-accounts
namespace: default
subjects:
- kind: ServiceAccount
name: skywiz-app-with-consul-client-poc-consul-client
namespace: default
roleRef:
kind: ClusterRole
name: service-account-getter
apiGroup: rbac.authorization.k8s.io- Litte wy tagongsrjochten oanmeitsje
kubectl create -f skywiz-poc-consul-server_rbac.yamlFerbine mei Consul Client
- As opmurken D'r binne ferskate opsjes foar ferbining mei daemonset, mar wy geane troch nei de folgjende ienfâldige oplossing:
- Tapasse de folgjende triem [].
### poc-consul-client-ds-svc.yaml
apiVersion: v1
kind: Service
metadata:
name: consul-ds-client
spec:
selector:
app: consul
chart: consul-helm
component: client
hasDNS: "true"
release: skywiz-app-with-consul-client-poc
ports:
- protocol: TCP
port: 80
targetPort: 8500- Brûk dan it folgjende ynboude kommando om in configmap te meitsjen []. Tink derom dat wy ferwize nei de namme fan ús tsjinst, ferfange it as nedich.
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
labels:
addonmanager.kubernetes.io/mode: EnsureExists
name: kube-dns
namespace: kube-system
data:
stubDomains: |
{"consul": ["$(kubectl get svc consul-ds-client -o jsonpath='{.spec.clusterIP}')"]}
EOFTesten fan de auth-metoade
Litte wy no de magy yn aksje sjen!
- Meitsje meardere kaaimappen mei deselde kaai op boppeste nivo (d.w.s. /sample_key) en in wearde fan jo kar. Meitsje passend belied en rollen foar nije kaaipaden. Wy sille de bindingen letter dwaan.
Oanpaste nammeromte test:
- Litte wy ús eigen nammeromte oanmeitsje:
kubectl create namespace custom-ns- Litte wy in pod oanmeitsje yn ús nije nammeromte. Skriuw de konfiguraasje foar de pod.
###poc-ubuntu-custom-ns.yaml
apiVersion: v1
kind: Pod
metadata:
name: poc-ubuntu-custom-ns
namespace: custom-ns
spec:
containers:
- name: poc-ubuntu-custom-ns
image: ubuntu
command: ["/bin/bash", "-ec", "sleep infinity"]
restartPolicy: Never- Meitsje ûnder:
kubectl create -f poc-ubuntu-custom-ns.yaml- Sadree't de kontener rint, gean dêr en ynstallearje curl.
kubectl exec poc-ubuntu-custom-ns -n custom-ns -it /bin/bash
apt-get update && apt-get install curl -y- No sille wy in oanmeldfersyk stjoere nei Consul mei de autorisaasjemetoade dy't wy earder makke hawwe [].
- Om it ynfierde token fan jo tsjinstaccount te besjen:
cat /run/secrets/kubernetes.io/serviceaccount/token- Skriuw it folgjende nei in bestân yn 'e kontener:
### payload.json
{
"AuthMethod": "auth-method-test",
"BearerToken": "<jwt_token>"
}- Oanmelde!
curl
--request POST
--data @payload.json
consul-ds-client.default.svc.cluster.local/v1/acl/login- Om de boppesteande stappen yn ien rigel te foltôgjen (om't wy meardere tests sille útfiere), kinne jo it folgjende dwaan:
echo "{
"AuthMethod": "auth-method-skywiz-consul-poc",
"BearerToken": "$(cat /run/secrets/kubernetes.io/serviceaccount/token)"
}"
| curl
--request POST
--data @-
consul-ds-client.default.svc.cluster.local/v1/acl/login- Wurket! It moat teminsten. Nim no de SecretID en besykje tagong te krijen ta de kaai / wearde dy't wy tagong moatte hawwe.
curl
consul-ds-client.default.svc.cluster.local/v1/kv/custom-ns/test_key --header “X-Consul-Token: <SecretID_from_prev_response>”- Jo kinne base64 dekodearje "Wearde" en sjen dat it oerienkomt mei de wearde yn custom-ns/test_key yn 'e UI. As jo deselde wearde hjirboppe yn dizze tutorial hawwe brûkt, soe jo kodearre wearde IkknbSBpbiB0aGUgY3VzdG9tLW5zIGZvbGRlciEi wêze.
Test foar brûkerstsjinstkonto:
- Meitsje in oanpaste ServiceAccount mei it folgjende kommando [].
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
name: custom-sa
EOF- Meitsje in nij konfiguraasjetriem foar de pod. Tink derom dat ik krulynstallaasje opnaam om arbeid te besparjen :)
###poc-ubuntu-custom-sa.yaml
apiVersion: v1
kind: Pod
metadata:
name: poc-ubuntu-custom-sa
namespace: default
spec:
serviceAccountName: custom-sa
containers:
- name: poc-ubuntu-custom-sa
image: ubuntu
command: ["/bin/bash","-ec"]
args: ["apt-get update && apt-get install curl -y; sleep infinity"]
restartPolicy: Never- Dêrnei rinne in shell yn 'e kontener.
kubectl exec -it poc-ubuntu-custom-sa /bin/bash- Oanmelde!
echo "{
"AuthMethod": "auth-method-skywiz-consul-poc",
"BearerToken": "$(cat /run/secrets/kubernetes.io/serviceaccount/token)"
}"
| curl
--request POST
--data @-
consul-ds-client.default.svc.cluster.local/v1/acl/login- Tastimming wegere. Oh, wy binne fergetten om in nije regels ta te foegjen dy't binend mei de passende tagongsrjochten, litte wy dat no dwaan.
Werhelje de foarige stappen hjirboppe:
a) Meitsje in identike belied foar it foarheaksel "custom-sa/".
b) Meitsje in rol, neam it "oanpaste-sa-rol"
c) Befestigje it Belied oan 'e Rol.
- Meitsje in Rule-Binding (allinich mooglik fan cli / api). Notysje de ferskillende betsjutting fan 'e seleksjeflagge.
consul acl binding-rule create
-method=auth-method-skywiz-consul-poc
-bind-type=role
-bind-name='custom-sa-role'
-selector='serviceaccount.name=="custom-sa"'- Oanmelde wer út de "poc-ubuntu-custom-sa" container. Sukses!
- Besjoch ús tagong ta it oanpaste-sa/-kaaipaad.
curl
consul-ds-client.default.svc.cluster.local/v1/kv/custom-sa/test_key --header “X-Consul-Token: <SecretID>”- Jo kinne ek soargje dat dit token gjin tagong jout ta kv yn "custom-ns/". Werhelje gewoan it boppesteande kommando nei it ferfangen fan "custom-sa" mei it foarheaksel "custom-ns".
Tastimming wegere.
Foarbyld fan Overlay:
- It is de muoite wurdich op te merken dat alle regel-binende mappings sille wurde tafoege oan it token mei dizze rjochten.
- Us kontener "poc-ubuntu-custom-sa" is yn 'e standert nammeromte - dus litte wy it brûke foar in oare regelferbining.
- Werhelje foarige stappen:
a) Meitsje in identike belied foar de "standert /" kaai foarheaksel.
b) Meitsje in rol, neam it "standert-ns-rol"
c) Befestigje it Belied oan 'e Rol. - Meitsje in regelbining (allinich mooglik fan cli/api)
consul acl binding-rule create
-method=auth-method-skywiz-consul-poc
-bind-type=role
-bind-name='default-ns-role'
-selector='serviceaccount.namespace=="default"'- Gean werom nei ús "poc-ubuntu-custom-sa" container en besykje tagong te krijen ta it "standert/" kv paad.
- Tastimming wegere.
Jo kinne de oantsjutte bewiisbrieven foar elke token besjen yn 'e UI ûnder ACL> Tokens. Sa't jo sjen kinne, hat ús hjoeddeistige token mar ien "oanpaste-sa-rol" ferbûn. It token dat wy op it stuit brûke is oanmakke doe't wy ynlogden en d'r wie mar ien regelferbining dy't doe oerien kaam. Wy moatte opnij oanmelde en it nije token brûke. - Soargje derfoar dat jo kinne lêze fan sawol de "custom-sa/" en "standert/" kv paden.
Sukses!
Dit komt om't ús "poc-ubuntu-custom-sa" oerienkomt mei de "oanpaste-sa" en "standert-ns" regelbindingen.
konklúzje
TTL token mgmt?
Op it stuit fan dit skriuwen is d'r gjin yntegreare manier om de TTL te bepalen foar tokens generearre troch dizze autorisaasjemetoade. It soe in fantastyske kâns wêze om feilige automatisearring fan Consul-autorisaasje te leverjen.
D'r is in opsje om manuell in token te meitsjen mei TTL:
Ferfaltiid - De tiid wêrop dit token sil wurde ynlutsen. (Opsjoneel; tafoege yn Consul 1.5.0)- Bestiet allinnich foar hânmjittich oanmeitsjen / update
Hooplik sille wy yn 'e heine takomst kinne kontrolearje hoe't tokens wurde generearre (per regel as autorisaasjemetoade) en TTL tafoegje.
Oant dan wurdt it suggerearre dat jo in einpunt foar ôfmelden brûke yn jo logika.
Lês ek oare artikels op ús blog:
Boarne: www.habr.com